cm9200

from Crypto.Util.number import *
from secret import flag

p = getPrime(512)
q = getPrime(512)
r = getPrime(512)

m = bytes_to_long(flag)

e = 65537

c = pow(m, e, p*q*r)

print(f'n = {p*q*r}')
print(f'pq = {p*q}')
print(f'c = {c}')

 CRT로 풀린다

from Crypto.Util.number import inverse,long_to_bytes
n = 750663646847528873168937831391907810647591913965562495296199585082759057318274521553757550724463451891668175905206221877858317290777877060166997790624527965837837993129383290402509996587556406778482067347232022225466937668396768390983554357611376057823852179263682649072729435912583278183812954787442057976301035654942470184201720410477691326653029842426252391647509934740335989269071438620690320401576861478427178128804784352142271832603194431176323445880836139
pq = 80970512687406090889060992576336286518763523653333428346066206717567693624044162491796922556346210471950404967161997779545603412053582932354160368128117099634532601019309976159157713252768640669410333127578132624183514430252557952811102781031315190048386214745340936679285725364013916829276058253922234988379
c = 221975957171552618997196127189899209276336291387640550554967727731818563960555600691881715668156105819191779108737770660990397331961689607338541452069797368288215716485835439777459317512238532636172979397173548812054679237802827275184091619620252887678664409116710340000218841023351238456144820005968602870644031701303645229364391309952172259686888808938835775360009896210855708140351244441167461823250549764537506364091367096196182191704433664638829177854628679




r = n / pq
#print inverse(65537,r-1)
d = 8528872622026277937550303553635609937097487502827424222476157017734084188054492606869179010958997338558262439273241708142496780631708632488343298528728513
print long_to_bytes(pow(c,d,r))

Electronic CodeBook Mode

✔ 병렬 연산이 가능합니다

✔ 암호화와 복호화 계산 중, 암호문 전송 시 에러전이가 발생하지 않습니다

⚠ 입력이 동일하면 출력도 동일합니다

Cipher Block Chaining Mode

✔ 초기 벡터값을 바꾸면 평문이 같아도 암호문이 달라집니다

✔ 병렬 복호화가 가능합니다 (역순으로 Dec function에 넣는다고 생각해보세요)

⚠ 병렬 암호화는 불가능합니다

⚠ 전송중 에러가 발생하면, 앞 뒤 부분에 영향을 줍니다 (복호화)

Cipher FeedBack Mode

✔ 초기 벡터값을 바꾸면 평문이 같아도 암호문이 달라집니다

✔ 병렬 복호화가 가능합니다

✔ 복호화를 구현할 필요가 없습니다 (xor연산이기 때문에)

⚠ 병렬 암호화는 불가능 합니다

⚠ 전송중 에러가 발생하면 몇 블록에 영향을 줍니다 (복호화)

(ppt 다시 만들기 귀찮아서 그냥 적는데, 위 모드에서 xor를 거친 r bit를, 즉 ppt에서 output이 cypertext이기에 이 모드의 이름이 Cipher feedback입니다)

Output FeedBack Mode

✔ 평문과 무관하게 미리 값을 계산할 수 있습니다. (chaining 되는것이 output이 아니기 때문)

✔ 초기 벡터값을 바꾸면 평문이 같아도 암호문은 달라집니다

✔ 복호화를 구현할 필요가 없습니다 (xor연산이기 때문에)

✔ 에러 전이가 없습니다

⚠ 전송중 데이터가 손실되면 복호화가 불가능합니다 

⚠ 병렬 연산이 불가능합니다

(ppt 다시 만들기 귀찮아서 그냥 적는데, 위 모드에서 enc를 거친 n 중 r bit를 output이라 하기에 이 모드의 이름이 outpput feedback입니다)

CounTeR Mode

✔ 평문과 무관하게 미리 값을 계산할 수 있습니다. (chaining 되는것이 output이 아니기 때문)

✔ CTR을 바꾸면 평문이 같아도 암호문은 달라집니다 

✔ 복호화를 구현할 필요가 없습니다 (xor연산이기 때문에)

✔ 에러 전이가 없습니다

⚠ 전송중 데이터가 손실되면 복호화가 불가능합니다

(에러 전이는 복호화 과정에서 생각합니다)

Bit Padding : 1000...으로 패딩

ANSI X.923 : 남은 바이트 수를 패딩 ( 4바이트가 남으면 00 00 00 04 로 패딩)

ISO 10126 : 나머지 바이트를 랜덤수로 패딩

PKCS #5 & PKCS #7 : 나머지 바이트 수로 나머지 바이트를 모두 패딩

ISO/IEC 7816-4 : 80 00 00 ..으로 패딩

Zero Padding : 00 00 00으로 패딩

def gcd(a, b):
    while b!=0:
        a, b = b, a%b
    return a

def decrypt(pk, ciphertext):
    key, n = pk
    plain = [chr((char ** key) % n) for char in ciphertext]
    return ''.join(plain)

def encrypt(pk, plaintext):
    key, n = pk
    cipher = [(ord(char) ** key) % n for char in plaintext]
    return cipher

def get_private_key(e, tot):
    k=1
    while (e*k)%tot != 1 or k == e:
        k+=1
    return k

def get_public_key(tot):
    e=2
    while e<totient and gcd(e, totient)!=1:
        e += 1
    return e
    ////////////////////////////////////////////////////
m = input("Enter the text to be encrypted:")
p = 13
q = 23

print("Two prime numbers(p and q) are:", str(p), "and", str(q))
n = p*q
print("n(p*q)=", str(p), "*", str(q), "=", str(n))
totient = (p-1)*(q-1)
print("(p-1)*(q-1)=", str(totient))
e = get_public_key(totient)
print("Public key(n, e):("+str(n)+","+str(e)+")")
d = get_private_key(e, totient)
print("Private key(n, d):("+str(n)+","+str(d)+")")
encrypted_msg = encrypt((e,n), m)
print('Encrypted Message:', ''.join(map(lambda x: str(x), encrypted_msg)))
print('Decrypted Message:', decrypt((d,n),encrypted_msg))
    

void setup() {
  // put your setup code here, to run once:
typedef unsigned char u8;
typedef unsigned int u32;
  

int i;
  u8 PT[16] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff };
  // 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
  u8 MK[16] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
  // 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
  u8 CT[16] = { 0x00 };
  // 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30, 0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a
  u8 RK[240] = { 0x00 }; /* Enough space for 256-bit master key */
  int keysize = 128;
  u32 W[60] = { 0x00 }; /* Enough space for 256-bit master key */
  u8 temp;

}

#define _CRT_SECURE_NO_WARNINGS
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

#define MUL2(a) (a << 1) ^ (a & 0x80 ? 0x1b : 0)
#define MUL3(a) (MUL2(a)) ^ (a) 
#define MUL4(a) (MUL2((MUL2(a)))) 
#define MUL8(a) (MUL2((MUL2((MUL2(a))))))
#define MUL9(a) (MUL8(a)) ^ (a)
#define MULB(a) (MUL8(a)) ^ (MUL2(a)) ^ (a)
#define MULD(a) (MUL8(a)) ^ (MUL4(a)) ^ (a)
#define MULE(a) (MUL8(a)) ^ (MUL4(a)) ^ (MUL2(a))
u8 Sbox[256] = {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};
void AddRoundKey(u8 S[16], u8 RK[16]) {
  S[0] ^= RK[0]; S[1] ^= RK[1]; S[2] ^= RK[2]; S[3] ^= RK[3];
  S[4] ^= RK[4]; S[5] ^= RK[5]; S[6] ^= RK[6]; S[7] ^= RK[7];
  S[8] ^= RK[8]; S[9] ^= RK[9]; S[10] ^= RK[10]; S[11] ^= RK[11];
  S[12] ^= RK[12]; S[13] ^= RK[13]; S[14] ^= RK[14]; S[15] ^= RK[15];
}

void SubBytes(u8 S[16]) {
  S[0] = Sbox[S[0]]; S[1] = Sbox[S[1]]; S[2] = Sbox[S[2]]; S[3] = Sbox[S[3]];
  S[4] = Sbox[S[4]]; S[5] = Sbox[S[5]]; S[6] = Sbox[S[6]]; S[7] = Sbox[S[7]];
  S[8] = Sbox[S[8]]; S[9] = Sbox[S[9]]; S[10] = Sbox[S[10]]; S[11] = Sbox[S[11]];
  S[12] = Sbox[S[12]]; S[13] = Sbox[S[13]]; S[14] = Sbox[S[14]]; S[15] = Sbox[S[15]];
}

void ShiftRows(u8 S[16]) {
  u8 temp;
  temp = S[1];  S[1] = S[5]; S[5] = S[9]; S[9] = S[13]; S[13] = temp;
  temp = S[2]; S[2] = S[10]; S[10] = temp; temp = S[6]; S[6] = S[14]; S[14] = temp;
  temp = S[15]; S[15] = S[11]; S[11] = S[7]; S[7] = S[3]; S[3] = temp;
}

void MixColumns(u8 S[16]) {
  u8 temp[16];
  int i;

  for (i = 0; i < 16; i += 4) {
    temp[i] = MUL2(S[i]) ^ MUL3(S[i + 1]) ^ S[i + 2] ^ S[i + 3];
    temp[i + 1] = S[i] ^ MUL2(S[i + 1]) ^ MUL3(S[i + 2]) ^ S[i + 3];
    temp[i + 2] = S[i] ^ S[i + 1] ^ MUL2(S[i + 2]) ^ MUL3(S[i + 3]);
    temp[i + 3] = MUL3(S[i]) ^ S[i + 1] ^ S[i + 2] ^ MUL2(S[i + 3]);
  }
  S[0] = temp[0]; S[1] = temp[1]; S[2] = temp[2]; S[3] = temp[3];
  S[4] = temp[4]; S[5] = temp[5]; S[6] = temp[6]; S[7] = temp[7];
  S[8] = temp[8]; S[9] = temp[9]; S[10] = temp[10]; S[11] = temp[11];
  S[12] = temp[12]; S[13] = temp[13]; S[14] = temp[14]; S[15] = temp[15];
}

void AES_ENC(u8 PT[16], u8 RK[], u8 CT[16], int keysize) {
  int Nr = keysize / 32 + 6;
  int i;
  u8 temp[16];

  for (i = 0; i < 16; i++)
    temp[i] = PT[i];

  AddRoundKey(temp, RK);

  for (i = 0; i < Nr - 1; i++) {
    SubBytes(temp);
    ShiftRows(temp);
    MixColumns(temp);
    AddRoundKey(temp, RK + 16 * (i + 1));
  }

  SubBytes(temp);
  ShiftRows(temp);
  AddRoundKey(temp, RK + 16 * (i + 1));

  for (i = 0; i < 16; i++)
    CT[i] = temp[i];
}

u32 u4byte_in(u8* x) {
  return (x[0] << 24) | (x[1] << 16) | (x[2] << 8) | x[3];
}

void u4byte_out(u8* x, u32 y) {
  x[0] = (y >> 24) & 0xff;
  x[1] = (y >> 16) & 0xff;
  x[2] = (y >> 8) & 0xff;
  x[3] = y & 0xff;
}

void AES_KeyWordToByte128(u32 W[], u8 RK[]) {
  int i;
  for (i = 0; i < 44; i++) {
    u4byte_out(RK + 4 * i, W[i]);
  }
}


u32 Rcons[10] = { 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000 };
#define RotWord(x) ((x << 8) | (x >> 24))
u32 SubWord(u32 x) {
  return ((u32)Sbox[(u8)(x >> 24)] << 24) | ((u32)Sbox[(u8)((x >> 16) & 0xff)] << 16) | ((u32)Sbox[(u8)((x >> 8) & 0xff)] << 8) | ((u32)Sbox[(u8)(x & 0xff)]);
}
void RoundKeyGeneration128(u8 MK[], u8 RK[]) {
  u32 W[44];
  int i;
  u32 T;

  W[0] = u4byte_in(MK);
  W[1] = u4byte_in(MK + 4);
  W[2] = u4byte_in(MK + 8);
  W[3] = u4byte_in(MK + 12);

  for (i = 0; i < 10; i++) {
    T = W[4 * i + 3];
    T = RotWord(T);
    T = SubWord(T);
    T ^= Rcons[i];

    W[4 * i + 4] = W[4 * i] ^ T;
    W[4 * i + 5] = W[4 * i + 1] ^ W[4 * i + 4];
    W[4 * i + 6] = W[4 * i + 2] ^ W[4 * i + 5];
    W[4 * i + 7] = W[4 * i + 3] ^ W[4 * i + 6];
  }
  AES_KeyWordToByte128(W, RK);
}

void AES_KeySchedule(u8 MK[], u8 RK[], int keysize) {
  if (keysize == 128) RoundKeyGeneration128(MK, RK);
  // else if (keysize == 192) RoundKeyGeneration192(MK, RK);
  // else if (keysize == 256) RoundKeyGeneration256(MK, RK);
}

int main() {
  
int i;
u8 PT[16];
printf("input plaintest");
scanf("%s", &PT);
  u8 MK[16] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
  // 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
  u8 CT[16] = { 0x00 };
  // 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30, 0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a
  u8 RK[240] = { 0x00 }; /* Enough space for 256-bit master key */
  int keysize = 128;
  u32 W[60] = { 0x00 }; /* Enough space for 256-bit master key */
  u8 temp;

  
  AES_KeySchedule(MK, RK, keysize);
  AES_ENC(PT, RK, CT, keysize);

  for (i = 0; i < 16; i++) {
    printf("%02x ", CT[i]);
  }

  return 0;
}

void loop() {
  // put your main code here, to run repeatedly:

}