Add files via upload
This commit is contained in:
Morgan_KR
GitHub
parent
ab67e6099e
commit
c084e33544
|
|
@ -0,0 +1,11 @@
|
|||
from prince64 import prince
|
||||
|
||||
plainfile = open("pt.dat", "rb")
|
||||
cipherfile = open("ct.dat", "rb")
|
||||
|
||||
pbyte = plainfile.read(8)
|
||||
cbyte = cipherfile.read(8)
|
||||
pbytearay = [((a&0x0F)<<4)|((a&0xF0)>>4) for a in list(pbyte)][::-1]
|
||||
cbytearay = [((a&0x0F)<<4)|((a&0xF0)>>4) for a in list(cbyte)][::-1]
|
||||
a = prince(pbytearay,[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
|
||||
a.start()
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
from random import *
|
||||
import math
|
||||
A = 0
|
||||
B = 7
|
||||
P = 2**21 - 1# 2**256 - 2**224 + 2**192 + 2**96 - 1
|
||||
|
||||
def doubleing(point):
|
||||
x1 = point[0]
|
||||
y1 = point[1]
|
||||
|
||||
lamda = ((3*(x1**2)+A) % P) * ((2*y1)**(P-2) % P) % P
|
||||
x2 = (lamda**2 - 2*x1) % P
|
||||
y2 = ((x1 - x2)*lamda - y1) % P
|
||||
|
||||
return (x2, y2)
|
||||
|
||||
def adding(point1, point2):
|
||||
x1 = point1[0]
|
||||
y1 = point1[1]
|
||||
x2 = point2[0]
|
||||
y2 = point2[1]
|
||||
|
||||
lamda = (((y2 - y1) % P) * ((x2 - x1)**(P-2) % P)) % P
|
||||
x3 = (lamda**2 - x1 - x2) % P
|
||||
y3 = ((x1 - x3) * lamda - y1) % P
|
||||
|
||||
return (x3, y3)
|
||||
|
||||
def muling(point, n):
|
||||
double = doubleing(point)
|
||||
if(n==2):
|
||||
return double
|
||||
elif(n==1):
|
||||
return point
|
||||
else:
|
||||
log2n = int(math.log(n, 2))
|
||||
mul = {}
|
||||
ddowl = double
|
||||
num = 2
|
||||
count = 1
|
||||
mul[2] = double
|
||||
mul[1] = point
|
||||
|
||||
while(log2n>count):
|
||||
tmp = doubleing(ddowl)
|
||||
num = num*2
|
||||
mul[num] = tmp
|
||||
ddowl = tmp
|
||||
count += 1
|
||||
|
||||
what = 1
|
||||
whatadd = []
|
||||
|
||||
while(n):
|
||||
if(n % 2 == 1):
|
||||
whatadd.append(what)
|
||||
what = what * 2
|
||||
n = int(n / 2)
|
||||
|
||||
result = mul[whatadd[0]]
|
||||
del(whatadd[0])
|
||||
if len(whatadd) >= 1:
|
||||
for i in whatadd:
|
||||
result = adding(result,mul[i])
|
||||
|
||||
return result
|
||||
|
||||
if __name__=="__main__":
|
||||
count = randint(0,2**1000)
|
||||
x1 = randint(0,2**1000)
|
||||
y1 = randint(0,2**1000)
|
||||
res = muling((x1,y1),count)
|
||||
print(hex(count), res, sep='\n')
|
||||
|
|
@ -0,0 +1,209 @@
|
|||
from dataclasses import dataclass
|
||||
from random import randint
|
||||
|
||||
|
||||
@dataclass
|
||||
class PrimeGaloisField:
|
||||
prime: int
|
||||
|
||||
def __contains__(self, field_value: "FieldElement") -> bool:
|
||||
|
||||
return 0 <= field_value.value < self.prime
|
||||
|
||||
|
||||
@dataclass
|
||||
class FieldElement:
|
||||
value: int
|
||||
field: PrimeGaloisField
|
||||
|
||||
def __repr__(self):
|
||||
return "0x" + f"{self.value:x}".zfill(64)
|
||||
|
||||
@property
|
||||
def P(self) -> int:
|
||||
return self.field.prime
|
||||
|
||||
def __add__(self, other: "FieldElement") -> "FieldElement":
|
||||
return FieldElement(
|
||||
value=(self.value + other.value) % self.P,
|
||||
field=self.field
|
||||
)
|
||||
|
||||
def __sub__(self, other: "FieldElement") -> "FieldElement":
|
||||
return FieldElement(
|
||||
value=(self.value - other.value) % self.P,
|
||||
field=self.field
|
||||
)
|
||||
|
||||
def __rmul__(self, scalar: int) -> "FieldValue":
|
||||
return FieldElement(
|
||||
value=(self.value * scalar) % self.P,
|
||||
field=self.field
|
||||
)
|
||||
|
||||
def __mul__(self, other: "FieldElement") -> "FieldElement":
|
||||
return FieldElement(
|
||||
value=(self.value * other.value) % self.P,
|
||||
field=self.field
|
||||
)
|
||||
|
||||
def __pow__(self, exponent: int) -> "FieldElement":
|
||||
return FieldElement(
|
||||
value=pow(self.value, exponent, self.P),
|
||||
field=self.field
|
||||
)
|
||||
|
||||
def __truediv__(self, other: "FieldElement") -> "FieldElement":
|
||||
other_inv = other ** -1
|
||||
return self * other_inv
|
||||
|
||||
|
||||
@dataclass
|
||||
class EllipticCurve:
|
||||
a: int
|
||||
b: int
|
||||
|
||||
field: PrimeGaloisField
|
||||
|
||||
def __contains__(self, point: "Point") -> bool:
|
||||
x, y = point.x, point.y
|
||||
return y ** 2 == x ** 3 + self.a * x + self.b
|
||||
|
||||
def __post_init__(self):
|
||||
|
||||
self.a = FieldElement(self.a, self.field)
|
||||
self.b = FieldElement(self.b, self.field)
|
||||
|
||||
if self.a not in self.field or self.b not in self.field:
|
||||
raise ValueError
|
||||
|
||||
|
||||
@dataclass
|
||||
class Point:
|
||||
x: int
|
||||
y: int
|
||||
|
||||
curve: EllipticCurve
|
||||
|
||||
def __post_init__(self):
|
||||
|
||||
if self.x is None and self.y is None:
|
||||
return
|
||||
|
||||
self.x = FieldElement(self.x, self.curve.field)
|
||||
self.y = FieldElement(self.y, self.curve.field)
|
||||
|
||||
if self not in self.curve:
|
||||
raise ValueError
|
||||
|
||||
def __add__(self, other):
|
||||
|
||||
if self == I:
|
||||
return other
|
||||
|
||||
if other == I:
|
||||
return self
|
||||
|
||||
if self.x == other.x and self.y == (-1 * other.y):
|
||||
return I
|
||||
|
||||
if self.x != other.x:
|
||||
x1, x2 = self.x, other.x
|
||||
y1, y2 = self.y, other.y
|
||||
|
||||
s = (y2 - y1) / (x2 - x1)
|
||||
x3 = s ** 2 - x1 - x2
|
||||
y3 = s * (x1 - x3) - y1
|
||||
|
||||
return self.__class__(
|
||||
x=x3.value,
|
||||
y=y3.value,
|
||||
curve=secp256k1
|
||||
)
|
||||
|
||||
if self == other and self.y == inf:
|
||||
return I
|
||||
|
||||
if self == other:
|
||||
x1, y1, a = self.x, self.y, self.curve.a
|
||||
|
||||
s = (3 * x1 ** 2 + a) / (2 * y1)
|
||||
x3 = s ** 2 - 2 * x1
|
||||
y3 = s * (x1 - x3) - y1
|
||||
|
||||
return self.__class__(
|
||||
x=x3.value,
|
||||
y=y3.value,
|
||||
curve=secp256k1
|
||||
)
|
||||
|
||||
def __rmul__(self, scalar: int) -> "Point":
|
||||
|
||||
current = self
|
||||
result = I
|
||||
while scalar:
|
||||
if scalar & 1:
|
||||
result = result + current
|
||||
current = current + current
|
||||
scalar >>= 1
|
||||
return result
|
||||
|
||||
|
||||
@dataclass
|
||||
class Signature:
|
||||
r: int
|
||||
s: int
|
||||
|
||||
def verify(self, z: int, pub_key: Point) -> bool:
|
||||
s_inv = pow(self.s, -1, N)
|
||||
u = (z * s_inv) % N
|
||||
v = (self.r * s_inv) % N
|
||||
|
||||
return (u*G + v*pub_key).x.value == self.r
|
||||
|
||||
|
||||
@dataclass
|
||||
class PrivateKey:
|
||||
secret: int
|
||||
|
||||
def sign(self, z: int) -> Signature:
|
||||
e = self.secret
|
||||
k = randint(0, N)
|
||||
R = k * G
|
||||
r = R.x.value
|
||||
k_inv = pow(k, -1, N)
|
||||
s = ((z + r*e) * k_inv) % N
|
||||
|
||||
return Signature(r, s)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
|
||||
A = 0
|
||||
B = 7
|
||||
|
||||
field = PrimeGaloisField(prime=P)
|
||||
secp256k1 = EllipticCurve(a=A, b=B, field=field)
|
||||
|
||||
G = Point(
|
||||
x=0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
|
||||
y=0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
|
||||
curve=secp256k1)
|
||||
|
||||
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
|
||||
|
||||
I = Point(x=None, y=None, curve=secp256k1)
|
||||
|
||||
inf = float("inf")
|
||||
|
||||
priv: int = 0xea11d6ada978a0b491aa5cbbe4df17a65c2fecc24448e95d1ccd854b43991bec
|
||||
e = PrivateKey(priv)
|
||||
|
||||
pub = e.secret * G
|
||||
print(pub)
|
||||
z = 0x7e240de74fb1ed08fa08d38063f6a6a91462a815
|
||||
|
||||
signature: Signature = e.sign(z)
|
||||
print(e.sign(z))
|
||||
assert signature.verify(z, pub)
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
class prince:
|
||||
def __init__(self, inL: list, inK: list):
|
||||
self.SBox = [0x0B, 0x0F, 0x03, 0x02, 0x0A, 0x0C, 0x09, 0x01, 0x06, 0x07, 0x08, 0x00, 0x0E, 0x05, 0x0D, 0x04]
|
||||
self.InvSBox = [0x0B, 0x07, 0x03, 0x02, 0x0F, 0x0D, 0x08, 0x09, 0x0A, 0x06, 0x04, 0x00, 0x05, 0x0E, 0x0C, 0x01]
|
||||
|
||||
self.RC = [
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x31, 0x91, 0xa8, 0xe2, 0x30, 0x07, 0x37, 0x44,
|
||||
0x4a, 0x90, 0x83, 0x22, 0x92, 0xf9, 0x13, 0x0d,
|
||||
0x80, 0xe2, 0xaf, 0x89, 0xce, 0xe4, 0xc6, 0x98
|
||||
]
|
||||
|
||||
self._plaintext = inL
|
||||
self.Key = inK
|
||||
|
||||
def cipher(self, ExKey):
|
||||
|
||||
self._plaintext = [self._plaintext[i] ^ ExKey[i] for i in range(8)]
|
||||
|
||||
self._AddKey(ExKey)
|
||||
self._RCLayer(0)
|
||||
|
||||
|
||||
self._SLayer()
|
||||
self._MLayer()
|
||||
self._RCLayer(1)
|
||||
self._AddKey(ExKey)
|
||||
|
||||
self._SLayer()
|
||||
self._MPrimeLayer()
|
||||
self._InvSLayer()
|
||||
|
||||
self._AddKey(ExKey)
|
||||
self._RCLayer(2)
|
||||
self._InvMLayer()
|
||||
self._InvSLayer()
|
||||
|
||||
self._RCLayer(3)
|
||||
self._AddKey(ExKey)
|
||||
|
||||
self._plaintext = [self._plaintext[i] ^ ExKey[i+8] for i in range(8)]
|
||||
|
||||
def ExtendKey(self, Key):
|
||||
newKey = [0x00] * 24
|
||||
|
||||
for i in range(8):
|
||||
newKey[i] = Key[i]
|
||||
newKey[i + 8] = (Key[i] >> 1) | (Key[(i + 1) % 8] << 7 & 0x80)
|
||||
newKey[i + 16] = Key[i + 8]
|
||||
|
||||
newKey[15] ^= (Key[7] & 0x10)
|
||||
|
||||
return newKey
|
||||
|
||||
def _SR(self):
|
||||
temp = self._plaintext[:]
|
||||
perm = [0, 5, 2, 7, 4, 1, 6, 3]
|
||||
|
||||
self._plaintext = [ (temp[perm[i]] & 0x0F) | (self._plaintext[perm[(i+2)%8]] & 0xF0) for i in range(8)]
|
||||
|
||||
|
||||
def _InvSR(self):
|
||||
temp = self._plaintext[:]
|
||||
perm = [0, 5, 2, 7, 4, 1, 6, 3]
|
||||
|
||||
self._plaintext = [ (temp[perm[i]] & 0x0F) | (self._plaintext[perm[(i+6)%8]] & 0xF0) for i in range(8)]
|
||||
|
||||
def _SLayer(self):
|
||||
self._plaintext = [ (self.SBox[self._plaintext[i] >> 4] << 4) | self.SBox[self._plaintext[i] & 0x0F] for i in range(8) ]
|
||||
|
||||
|
||||
def _InvSLayer(self):
|
||||
self._plaintext = [ (self.InvSBox[self._plaintext[i] >> 4] << 4) | self.InvSBox[self._plaintext[i] & 0x0F] for i in range(8) ]
|
||||
|
||||
def _MPrimeLayer(self):
|
||||
temp = self._plaintext[0]
|
||||
self._plaintext[0] = (temp & 0xD7) ^ (self._plaintext[1] & 0x7D) ^ (temp >> 4 & 0x0B) ^ (self._plaintext[1] >> 4 & 0x0E) ^ (temp << 4 & 0xB0) ^ (self._plaintext[1] << 4 & 0xE0)
|
||||
self._plaintext[1] = (temp & 0x7D) ^ (self._plaintext[1] & 0xD7) ^ (temp >> 4 & 0x0E) ^ (self._plaintext[1] >> 4 & 0x0B) ^ (temp << 4 & 0xE0) ^ (self._plaintext[1] << 4 & 0xB0)
|
||||
temp = self._plaintext[2]
|
||||
self._plaintext[2] = (temp & 0xEB) ^ (self._plaintext[3] & 0xBE) ^ (temp >> 4 & 0x0D) ^ (self._plaintext[3] >> 4 & 0x07) ^ (temp << 4 & 0xD0) ^ (self._plaintext[3] << 4 & 0x70)
|
||||
self._plaintext[3] = (temp & 0xBE) ^ (self._plaintext[3] & 0xEB) ^ (temp >> 4 & 0x07) ^ (self._plaintext[3] >> 4 & 0x0D) ^ (temp << 4 & 0x70) ^ (self._plaintext[3] << 4 & 0xD0)
|
||||
temp = self._plaintext[4]
|
||||
self._plaintext[4] = (temp & 0xEB) ^ (self._plaintext[5] & 0xBE) ^ (temp >> 4 & 0x0D) ^ (self._plaintext[5] >> 4 & 0x07) ^ (temp << 4 & 0xD0) ^ (self._plaintext[5] << 4 & 0x70)
|
||||
self._plaintext[5] = (temp & 0xBE) ^ (self._plaintext[5] & 0xEB) ^ (temp >> 4 & 0x07) ^ (self._plaintext[5] >> 4 & 0x0D) ^ (temp << 4 & 0x70) ^ (self._plaintext[5] << 4 & 0xD0)
|
||||
temp = self._plaintext[6]
|
||||
self._plaintext[6] = (temp & 0xD7) ^ (self._plaintext[7] & 0x7D) ^ (temp >> 4 & 0x0B) ^ (self._plaintext[7] >> 4 & 0x0E) ^ (temp << 4 & 0xB0) ^ (self._plaintext[7] << 4 & 0xE0)
|
||||
self._plaintext[7] = (temp & 0x7D) ^ (self._plaintext[7] & 0xD7) ^ (temp >> 4 & 0x0E) ^ (self._plaintext[7] >> 4 & 0x0B) ^ (temp << 4 & 0xE0) ^ (self._plaintext[7] << 4 & 0xB0)
|
||||
|
||||
def _MLayer(self):
|
||||
self._MPrimeLayer()
|
||||
self._SR()
|
||||
|
||||
def _InvMLayer(self):
|
||||
self._InvSR()
|
||||
self._MPrimeLayer()
|
||||
|
||||
def _RCLayer(self, round):
|
||||
self._plaintext = [ self._plaintext[i] ^ self.RC[8 * round + i] for i in range(8)]
|
||||
|
||||
def _AddKey(self, ExKey):
|
||||
self._plaintext = [ self._plaintext[i] ^ ExKey[i + 16] for i in range(8) ]
|
||||
|
||||
def prince(self):
|
||||
ExKey = self.ExtendKey(self.Key)
|
||||
self.cipher(ExKey)
|
||||
return [nibble >> 4 | (nibble << 4 & 0xF0) for nibble in self._plaintext]
|
||||
|
||||
def start(self):
|
||||
ExKey = self.ExtendKey(self.Key)
|
||||
self.cipher(ExKey)
|
||||
print('0x', end='')
|
||||
for i in range(8):
|
||||
print(format(self._plaintext[i] >> 4 | (self._plaintext[i] << 4 & 0xF0), '02x'), end='')
|
||||
print()
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
|
||||
|
||||
SBox = [0x0B, 0x0F, 0x03, 0x02, 0x0A, 0x0C, 0x09, 0x01, 0x06, 0x07, 0x08, 0x00, 0x0E, 0x05, 0x0D, 0x04]
|
||||
# Inverse substitution box used on individual nibbles
|
||||
InvSBox = [0x0B, 0x07, 0x03, 0x02, 0x0F, 0x0D, 0x08, 0x09, 0x0A, 0x06, 0x04, 0x00, 0x05, 0x0E, 0x0C, 0x01]
|
||||
|
||||
RC = [
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x31, 0x91, 0xa8, 0xe2, 0x30, 0x07, 0x37, 0x44,
|
||||
0x4a, 0x90, 0x83, 0x22, 0x92, 0xf9, 0x13, 0x0d,
|
||||
0x80, 0xe2, 0xaf, 0x89, 0xce, 0xe4, 0xc6, 0x98
|
||||
]
|
||||
|
||||
_State = [0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]
|
||||
Key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01]
|
||||
|
||||
def cipher(ExtendedKey):
|
||||
""" The complete PRINCE forward encryption on the 64-bit state performed through nibble calculations """
|
||||
global _State
|
||||
|
||||
_State = [_State[i] ^ ExtendedKey[i] for i in range(8)]
|
||||
|
||||
_AddKey(ExtendedKey)
|
||||
_AddRoundConstant(0)
|
||||
|
||||
|
||||
_SubNibbles()
|
||||
_MLayer()
|
||||
_AddRoundConstant(1)
|
||||
_AddKey(ExtendedKey)
|
||||
|
||||
_SubNibbles()
|
||||
_MPrimeLayer()
|
||||
_InvSubNibbles()
|
||||
|
||||
_AddKey(ExtendedKey)
|
||||
_AddRoundConstant(2)
|
||||
_InvMLayer()
|
||||
_InvSubNibbles()
|
||||
|
||||
_AddRoundConstant(3)
|
||||
_AddKey(ExtendedKey)
|
||||
|
||||
_State = [_State[i] ^ ExtendedKey[i+8] for i in range(8)]
|
||||
|
||||
def ExtendKey(Key):
|
||||
""" PRINCE's version of a key schedule, which extends our 128-bit key to a 192-bit key """
|
||||
newKey = [0x00] * 24
|
||||
|
||||
for i in range(8):
|
||||
# k_0 stays the same
|
||||
newKey[i] = Key[i]
|
||||
# k'_0 is a k_0 rotated right one bit and XORed with the last bit
|
||||
newKey[i + 8] = (Key[i] >> 1) | (Key[(i + 1) % 8] << 7 & 0x80)
|
||||
# k_1 stays the same
|
||||
newKey[i + 16] = Key[i + 8]
|
||||
|
||||
newKey[15] ^= (Key[7] & 0x10)
|
||||
|
||||
return newKey
|
||||
|
||||
def _ShiftRows():
|
||||
""" Helper method which distinguishes our two linear layers M from M' """
|
||||
global _State
|
||||
|
||||
temp = _State[:] # copy the state into a temporary holder
|
||||
perm = [0, 5, 2, 7, 4, 1, 6, 3]
|
||||
|
||||
_State = [ (temp[perm[i]] & 0x0F) | (_State[perm[(i+2)%8]] & 0xF0) for i in range(8)]
|
||||
|
||||
|
||||
def _InvShiftRows():
|
||||
""" Inverse of our ShiftRows() function which allows us to distinguish M'^-1 from M^-1 """
|
||||
global _State
|
||||
|
||||
temp = _State[:] # copy the state into a temporary holder
|
||||
perm = [0, 5, 2, 7, 4, 1, 6, 3]
|
||||
|
||||
_State = [ (temp[perm[i]] & 0x0F) | (_State[perm[(i+6)%8]] & 0xF0) for i in range(8)]
|
||||
|
||||
|
||||
def _SubNibbles():
|
||||
""" Send the state through a substitution layer nibble-by-nibble """
|
||||
global _State
|
||||
_State = [ (SBox[_State[i] >> 4] << 4) | SBox[_State[i] & 0x0F] for i in range(8) ]
|
||||
|
||||
|
||||
def _InvSubNibbles():
|
||||
""" Inverse of our substitution layer which sends each substituted nibble back to the original nibble """
|
||||
global _State
|
||||
_State = [ (InvSBox[_State[i] >> 4] << 4) | InvSBox[_State[i] & 0x0F] for i in range(8) ]
|
||||
|
||||
|
||||
def _MPrimeLayer():
|
||||
""" Our linear layer, designed to use as little space as possible and prevent wasted clock-cycles. Recall that this method is in fact its own inverse. """
|
||||
global _State
|
||||
|
||||
# M0
|
||||
temp = _State[0] # we only need 1 storage variable here
|
||||
_State[0] = (temp & 0xD7) ^ (_State[1] & 0x7D) ^ (temp >> 4 & 0x0B) ^ (_State[1] >> 4 & 0x0E) ^ (temp << 4 & 0xB0) ^ (_State[1] << 4 & 0xE0)
|
||||
_State[1] = (temp & 0x7D) ^ (_State[1] & 0xD7) ^ (temp >> 4 & 0x0E) ^ (_State[1] >> 4 & 0x0B) ^ (temp << 4 & 0xE0) ^ (_State[1] << 4 & 0xB0)
|
||||
# M1
|
||||
temp = _State[2]
|
||||
_State[2] = (temp & 0xEB) ^ (_State[3] & 0xBE) ^ (temp >> 4 & 0x0D) ^ (_State[3] >> 4 & 0x07) ^ (temp << 4 & 0xD0) ^ (_State[3] << 4 & 0x70)
|
||||
_State[3] = (temp & 0xBE) ^ (_State[3] & 0xEB) ^ (temp >> 4 & 0x07) ^ (_State[3] >> 4 & 0x0D) ^ (temp << 4 & 0x70) ^ (_State[3] << 4 & 0xD0)
|
||||
# M1
|
||||
temp = _State[4]
|
||||
_State[4] = (temp & 0xEB) ^ (_State[5] & 0xBE) ^ (temp >> 4 & 0x0D) ^ (_State[5] >> 4 & 0x07) ^ (temp << 4 & 0xD0) ^ (_State[5] << 4 & 0x70)
|
||||
_State[5] = (temp & 0xBE) ^ (_State[5] & 0xEB) ^ (temp >> 4 & 0x07) ^ (_State[5] >> 4 & 0x0D) ^ (temp << 4 & 0x70) ^ (_State[5] << 4 & 0xD0)
|
||||
# M0
|
||||
temp = _State[6]
|
||||
_State[6] = (temp & 0xD7) ^ (_State[7] & 0x7D) ^ (temp >> 4 & 0x0B) ^ (_State[7] >> 4 & 0x0E) ^ (temp << 4 & 0xB0) ^ (_State[7] << 4 & 0xE0)
|
||||
_State[7] = (temp & 0x7D) ^ (_State[7] & 0xD7) ^ (temp >> 4 & 0x0E) ^ (_State[7] >> 4 & 0x0B) ^ (temp << 4 & 0xE0) ^ (_State[7] << 4 & 0xB0)
|
||||
|
||||
def _MLayer():
|
||||
""" The adjusted linear layer which is utilized each regular round """
|
||||
_MPrimeLayer()
|
||||
_ShiftRows()
|
||||
|
||||
def _InvMLayer():
|
||||
""" The inverse adjusted linear layer which is utilized each inverse regular round """
|
||||
_InvShiftRows()
|
||||
_MPrimeLayer()
|
||||
|
||||
def _AddRoundConstant(round):
|
||||
""" Function which simply applies a given round's constant to the state """
|
||||
global _State
|
||||
_State = [ _State[i] ^ RC[8 * round + i] for i in range(8)]
|
||||
|
||||
def _AddKey(ExtendedKey):
|
||||
""" Function which adds k_1 to the state """
|
||||
global _State
|
||||
_State = [ _State[i] ^ ExtendedKey[i + 16] for i in range(8) ]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
ExtendedKey = ExtendKey(Key)
|
||||
cipher(ExtendedKey)
|
||||
print('0x', end='')
|
||||
for i in range(8):
|
||||
print(format(_State[i] >> 4 | (_State[i] << 4 & 0xF0), '02x'), end='')
|
||||
print()
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
G = Point(
|
||||
x=0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
|
||||
y=0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
|
||||
curve=secp256k1)
|
||||
|
||||
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
|
||||
|
||||
I = Point(x=None, y=None, curve=secp256k1)
|
||||
|
||||
assert N * G == I
|
||||
|
||||
pub = Point(
|
||||
x=0x9577FF57C8234558F293DF502CA4F09CBC65A6572C842B39B366F21717945116,
|
||||
y=0x10B49C67FA9365AD7B90DAB070BE339A1DAF9052373EC30FFAE4F72D5E66D053,
|
||||
curve=secp256k1
|
||||
)
|
||||
d: int = 2 ** 240 + 2 ** 31
|
||||
print(d * G)
|
||||
print(pub)
|
||||
|
||||
e = PrivateKey(randint(0, N))
|
||||
pub = e.secret * G
|
||||
z = randint(0, 2 ** 256)
|
||||
signature: Signature = e.sign(z)
|
||||
assert signature.verify(z, pub)
|
||||
|
|
@ -0,0 +1,175 @@
|
|||
|
||||
|
||||
SBox = [0x0B, 0x0F, 0x03, 0x02, 0x0A, 0x0C, 0x09, 0x01, 0x06, 0x07, 0x08, 0x00, 0x0E, 0x05, 0x0D, 0x04]
|
||||
# Inverse substitution box used on individual nibbles
|
||||
InvSBox = [0x0B, 0x07, 0x03, 0x02, 0x0F, 0x0D, 0x08, 0x09, 0x0A, 0x06, 0x04, 0x00, 0x05, 0x0E, 0x0C, 0x01]
|
||||
|
||||
RC = [
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x31, 0x91, 0xa8, 0xe2, 0x30, 0x07, 0x37, 0x44,
|
||||
0x4a, 0x90, 0x83, 0x22, 0x92, 0xf9, 0x13, 0x0d,
|
||||
0x80, 0xe2, 0xaf, 0x89, 0xce, 0xe4, 0xc6, 0x98
|
||||
]
|
||||
|
||||
|
||||
def cipher(ExtendedKey):
|
||||
""" The complete PRINCE forward encryption on the 64-bit state performed through nibble calculations """
|
||||
global _State
|
||||
|
||||
_State = [_State[i] ^ ExtendedKey[i] for i in range(8)]
|
||||
|
||||
_AddKey(ExtendedKey)
|
||||
_AddRoundConstant(0)
|
||||
|
||||
|
||||
_SubNibbles()
|
||||
_MLayer()
|
||||
_AddRoundConstant(1)
|
||||
_AddKey(ExtendedKey)
|
||||
|
||||
_SubNibbles()
|
||||
_MPrimeLayer()
|
||||
_InvSubNibbles()
|
||||
|
||||
_AddKey(ExtendedKey)
|
||||
_AddRoundConstant(2)
|
||||
_InvMLayer()
|
||||
_InvSubNibbles()
|
||||
|
||||
_AddRoundConstant(3)
|
||||
_AddKey(ExtendedKey)
|
||||
|
||||
_State = [_State[i] ^ ExtendedKey[i+8] for i in range(8)]
|
||||
|
||||
def ExtendKey(Key):
|
||||
""" PRINCE's version of a key schedule, which extends our 128-bit key to a 192-bit key """
|
||||
newKey = [0x00] * 24
|
||||
|
||||
for i in range(8):
|
||||
# k_0 stays the same
|
||||
newKey[i] = Key[i]
|
||||
# k'_0 is a k_0 rotated right one bit and XORed with the last bit
|
||||
newKey[i + 8] = (Key[i] >> 1) | (Key[(i + 1) % 8] << 7 & 0x80)
|
||||
# k_1 stays the same
|
||||
newKey[i + 16] = Key[i + 8]
|
||||
|
||||
newKey[15] ^= (Key[7] & 0x10)
|
||||
|
||||
return newKey
|
||||
|
||||
def _ShiftRows():
|
||||
""" Helper method which distinguishes our two linear layers M from M' """
|
||||
global _State
|
||||
|
||||
temp = _State[:] # copy the state into a temporary holder
|
||||
perm = [0, 5, 2, 7, 4, 1, 6, 3]
|
||||
|
||||
_State = [ (temp[perm[i]] & 0x0F) | (_State[perm[(i+2)%8]] & 0xF0) for i in range(8)]
|
||||
|
||||
|
||||
def _InvShiftRows():
|
||||
""" Inverse of our ShiftRows() function which allows us to distinguish M'^-1 from M^-1 """
|
||||
global _State
|
||||
|
||||
temp = _State[:] # copy the state into a temporary holder
|
||||
perm = [0, 5, 2, 7, 4, 1, 6, 3]
|
||||
|
||||
_State = [ (temp[perm[i]] & 0x0F) | (_State[perm[(i+6)%8]] & 0xF0) for i in range(8)]
|
||||
|
||||
|
||||
def _SubNibbles():
|
||||
""" Send the state through a substitution layer nibble-by-nibble """
|
||||
global _State
|
||||
_State = [ (SBox[_State[i] >> 4] << 4) | SBox[_State[i] & 0x0F] for i in range(8) ]
|
||||
|
||||
|
||||
def _InvSubNibbles():
|
||||
""" Inverse of our substitution layer which sends each substituted nibble back to the original nibble """
|
||||
global _State
|
||||
_State = [ (InvSBox[_State[i] >> 4] << 4) | InvSBox[_State[i] & 0x0F] for i in range(8) ]
|
||||
|
||||
|
||||
def _MPrimeLayer():
|
||||
""" Our linear layer, designed to use as little space as possible and prevent wasted clock-cycles. Recall that this method is in fact its own inverse. """
|
||||
global _State
|
||||
|
||||
# M0
|
||||
temp = _State[0] # we only need 1 storage variable here
|
||||
_State[0] = (temp & 0xD7) ^ (_State[1] & 0x7D) ^ (temp >> 4 & 0x0B) ^ (_State[1] >> 4 & 0x0E) ^ (temp << 4 & 0xB0) ^ (_State[1] << 4 & 0xE0)
|
||||
_State[1] = (temp & 0x7D) ^ (_State[1] & 0xD7) ^ (temp >> 4 & 0x0E) ^ (_State[1] >> 4 & 0x0B) ^ (temp << 4 & 0xE0) ^ (_State[1] << 4 & 0xB0)
|
||||
# M1
|
||||
temp = _State[2]
|
||||
_State[2] = (temp & 0xEB) ^ (_State[3] & 0xBE) ^ (temp >> 4 & 0x0D) ^ (_State[3] >> 4 & 0x07) ^ (temp << 4 & 0xD0) ^ (_State[3] << 4 & 0x70)
|
||||
_State[3] = (temp & 0xBE) ^ (_State[3] & 0xEB) ^ (temp >> 4 & 0x07) ^ (_State[3] >> 4 & 0x0D) ^ (temp << 4 & 0x70) ^ (_State[3] << 4 & 0xD0)
|
||||
# M1
|
||||
temp = _State[4]
|
||||
_State[4] = (temp & 0xEB) ^ (_State[5] & 0xBE) ^ (temp >> 4 & 0x0D) ^ (_State[5] >> 4 & 0x07) ^ (temp << 4 & 0xD0) ^ (_State[5] << 4 & 0x70)
|
||||
_State[5] = (temp & 0xBE) ^ (_State[5] & 0xEB) ^ (temp >> 4 & 0x07) ^ (_State[5] >> 4 & 0x0D) ^ (temp << 4 & 0x70) ^ (_State[5] << 4 & 0xD0)
|
||||
# M0
|
||||
temp = _State[6]
|
||||
_State[6] = (temp & 0xD7) ^ (_State[7] & 0x7D) ^ (temp >> 4 & 0x0B) ^ (_State[7] >> 4 & 0x0E) ^ (temp << 4 & 0xB0) ^ (_State[7] << 4 & 0xE0)
|
||||
_State[7] = (temp & 0x7D) ^ (_State[7] & 0xD7) ^ (temp >> 4 & 0x0E) ^ (_State[7] >> 4 & 0x0B) ^ (temp << 4 & 0xE0) ^ (_State[7] << 4 & 0xB0)
|
||||
|
||||
def _MLayer():
|
||||
""" The adjusted linear layer which is utilized each regular round """
|
||||
_MPrimeLayer()
|
||||
_ShiftRows()
|
||||
|
||||
def _InvMLayer():
|
||||
""" The inverse adjusted linear layer which is utilized each inverse regular round """
|
||||
_InvShiftRows()
|
||||
_MPrimeLayer()
|
||||
|
||||
def _AddRoundConstant(round):
|
||||
""" Function which simply applies a given round's constant to the state """
|
||||
global _State
|
||||
_State = [ _State[i] ^ RC[8 * round + i] for i in range(8)]
|
||||
|
||||
def _AddKey(ExtendedKey):
|
||||
""" Function which adds k_1 to the state """
|
||||
global _State
|
||||
_State = [ _State[i] ^ ExtendedKey[i + 16] for i in range(8) ]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# _State = [0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE]
|
||||
# Key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01]
|
||||
|
||||
# ExtendedKey = ExtendKey(Key)
|
||||
# cipher(ExtendedKey)
|
||||
# print('0x', end='')
|
||||
# for i in range(8):
|
||||
# print(format(_State[i] >> 4 | (_State[i] << 4 & 0xF0), '02x'), end='')
|
||||
# print()
|
||||
|
||||
plainfile = open("pt.dat", "rb")
|
||||
cipherfile = open("ct.dat", "rb")
|
||||
|
||||
key = []
|
||||
for i in range(16):
|
||||
key.append(bytearray(8))
|
||||
|
||||
active = [15,14,13,12,11]
|
||||
for t in range(5):
|
||||
# for each SET
|
||||
A = []
|
||||
for i in range(16):
|
||||
A.append(bytearray(16))
|
||||
|
||||
for j in range(t*16,(t+1)*16):
|
||||
pbyte = plainfile.read(8)
|
||||
cbyte = cipherfile.read(8)
|
||||
pbytearay = [((a&0x0F)<<4)|((a&0xF0)>>4) for a in list(pbyte)][::-1]
|
||||
cbytearay = [((a&0x0F)<<4)|((a&0xF0)>>4) for a in list(cbyte)][::-1]
|
||||
nibarray = []
|
||||
for dibble in [(str(hex(i))).replace('0x','') for i in cbytearay]:
|
||||
dibble = dibble.zfill(2)
|
||||
nibarray.append(dibble[0])
|
||||
nibarray.append(dibble[1])
|
||||
|
||||
for i in range(16):
|
||||
x = int('0x'+str(nibarray[i]),16)
|
||||
A[i][x] = 1
|
||||
|
||||
for i in range(16):
|
||||
print([[a[0:4],a[4:8],a[8:12],a[12:16]] for a in A])
|
||||
Loading…
Reference in New Issue