Changeset 263 for trunk

Timestamp:

04/06/09 11:41:44 (3 years ago)

Author:

ocjhb

Message:

first oc2 coin minted

Location:

trunk/sandbox/jhb/oc2

Files:

• documentation.py (modified) (1 diff)
• messages.py (modified) (2 diffs)
• mint.py (modified) (1 diff)
• occrypto_rsa.py (modified) (1 diff)
• protocols.py (modified) (3 diffs)
• rsa.py (modified) (2 diffs)
• testserver.py (modified) (2 diffs)

trunk/sandbox/jhb/oc2/documentation.py

@@ -441 +441 @@
 
 
+###############################################################################
+
+>>> clientside = protocols.TransferRequest(transport,tid,'foo',[[mkc.keyId,blind]],[])
+>>> testserver.run_once(port,issuer,mint)
+>>> text,value =  clientside.run()
+>>> text
+u'minted'
+>>> blindsign = value[0][1]
+>>> blank.signature = key.unblind(secret,blindsign)
+>>> coin = blank
+>>> key.verifyContainerSignature(coin)
+True
+
+###############################################################################
 3.5 Wallet gets token back
 

trunk/sandbox/jhb/oc2/messages.py

@@ -31 +31 @@
     ]
 
-class TransferToken(Message):
+class TransferRequest(Message):
      fields = Message.fields + [
         Field('transactionId'),
@@ -40 +40 @@
     ]
 
+class TransferAccept(Message):
+    fields = Message.fields + [
+        Field('text'),
+        Field('signatures'),
+    ]
 

trunk/sandbox/jhb/oc2/mint.py

@@ -21 +21 @@
 
     def _addMintKey(self,priv,pub,denomination,version=-1):
-        keylist = self.storage.setdefault('keys',[])
-        if version -1 > len(keylist) or len(keylist)==0:
-            keylist.append({})
-        keylist[version][denomination] = (priv,pub)
+        keys = self.storage.setdefault('keys',[])
+        keyids = self.storage.setdefault('keyids',{})
+        if version -1 > len(keys) or len(keys)==0:
+            keys.append({})
+        keys[version][denomination] = [priv,pub]
+        if version == -1:
+            version = len(keys) -1
+        keyids[pub.hash()] = [priv,pub,denomination,version]
 
-    def getMintKey(self,denomination,version=-1):
-        keylist = self.storage['keys']
-        return keylist[version][denomination][version] 
+    def getMintKeyByDenomination(self,denomination,version=-1):
+        return self.storage['keys'][version][denomination]
+
+    def getMintKeyById(self,keyid):
+        return self.storage['keyids'][keyid]
+
+    def denominationToValue(self,denomination):
+        return int(denomination)
+
+    def validateTarget(self,target,amount):
+        return True
+
+    def mintBlinds(self,target,blinds):
+        amount = 0
+        currentversion = len(self.storage['keys']) - 1
+        errors = None
+        result = []
+        mintkeys = []
+
+        for keyid,blind in blinds:
+            error = None
+            priv,pub,denomination,version = self.getMintKeyById(keyid)
+            mintkeys.append(priv)
+            if version != currentversion:
+                error = 'Key not current'
+            
+            if error:
+                errors = True
+                result.append(('error',error))
+            else:
+                result.append(['ok',''])
+    
+            amount += self.denominationToValue(denomination)
+        
+        if errors:
+            return ('errors',result)
+
+        valid = self.validateTarget(target,amount)
+
+        if not valid:
+            return ('nonvalid','')
+
+        if valid and not errors:
+            i = 0
+            for keyid,blind in blinds:
+                signature = mintkeys[i].sign(blind)
+                result[i][1] = signature
+                i += 1
+                        
+        return ('minted',result)
+
+

trunk/sandbox/jhb/oc2/occrypto_rsa.py

@@ -43 +43 @@
     def blind(self,data):
         secret = self.createBlindingSecret()
-        blinder =  rsa.powMod(rsa.invMod(secret, self.key['n']), self.key['e'], self.key['n'])
+        blinder =  pow(rsa.invMod(secret, self.key['n']), self.key['e'], self.key['n'])
         blinded = rsa.blind(data,blinder,self.key)
         return secret, blinded

trunk/sandbox/jhb/oc2/protocols.py

@@ -73 +73 @@
         return answer
 
+class TransferRequest(Protocol):
+    def __init__(self,transport,transactionId,target=None,blinds=None,coins=None):
+        self.transport = transport
+        self.transactionId=transactionId
+        self.target = target
+        self.blinds = blinds
+        self.coins = coins
 
+    def run(self,message=None):
+        if self.target and self.blinds:
+            type = 'mint'
+        elif self.target and self.coins:
+            type = 'redeem'
+        elif self.blinds and self.coins:
+            type = 'exchange'
+        else:
+            raise 'Not a valid combination of options'
+        
+        message = messages.TransferRequest()
+        message.transactionId = self.transactionId
+        message.target = self.target
+        message.blinds = self.blinds
+        message.coins = self.coins
+        message.options = dict(type=type).items()
 
+        response = self.transport(message)
+        header = response.header
+        if header == 'TransferReject':
+            return ('TRansferReject','')
+        elif header == 'TransferDelay':
+            return ('TransferDelay','')
+        elif header == 'TransferAccept':
+            return (response.text,response.signatures)
+        else:
+            raise 'unknown thing'
+
+class TransferHandle(Protocol):
+
+    def __init__(self,mint):
+        self.mint = mint
+
+    def run(self,message):
+        options = dict(message.options)
+        type = options['type']
+        if type == 'mint':
+            text,value = self.mint.mintBlinds(message.target,message.blinds)
+            if text == 'minted':
+                answer = messages.TransferAccept()
+                answer.text = text
+                answer.signatures = value
+            else:
+                raise 'something went wrong'
+        return answer    
 
 class CoinsSpendSender(Protocol):
@@ -89 +140 @@
 
 
+
 class CoinsSpendRecipient(Protocol):
 
@@ -98 +150 @@
 
 
-class TransferCoinsSender(Protocol):
-    
-    def __init__(self,target,blinds,coins):
-        self.target = target
-        self.blinds = blinds
-        self.coins = coins
 
-
-
-    def transferCoins(self,message):
-        return ''
-
-
-class TransferCoinRecipient(Protocol):
-    
-    def receiveCoins(self,message):
-        return ''
-
-
-

trunk/sandbox/jhb/oc2/rsa.py

@@ -23 +23 @@
 # Get os.urandom PRNG
 import os
-try:
-    raise Exception
-    os.urandom(1)
-    def getRandomBytes(howMany):
-        return stringToBytes(os.urandom(howMany))
-    grbname = 'urandom'        
-except:
-
-    def getRandomBytes(howMany):
-        bits = howMany * 8
-        number = random.getrandbits(bits)
-        return numberToBytes(number)
-        pass
-    grbname = 'randint'        
+def getRandomBytes(howMany):
+    bits = howMany * 8
+    number = random.getrandbits(bits)
+    return numberToBytes(number)
+  
 
 def log(x, base = 10):
@@ -171 +162 @@
 
 def generate(bits):  #needed
-    #return (dummypub,dummypriv)
+    return (dummypub,dummypriv)
     p = getRandomPrime(bits/2, False)
     q = getRandomPrime(bits/2, False)

trunk/sandbox/jhb/oc2/testserver.py

@@ -17 +17 @@
         elif message.header == 'FetchMintKeys':
             protocol = protocols.GiveMintKeys(self.issuer)
+        elif message.header == 'TransferRequest':
+            protocol = protocols.TransferHandle(self.mint)
         answer = protocol.run(message)
         self.send_response(200)
@@ -24 +26 @@
 
 
-def run_once(port,issuer=None):
+def run_once(port,issuer=None,mint=None):
     Handler.issuer = issuer
+    Handler.mint = mint
     httpd = BaseHTTPServer.HTTPServer(("", port), Handler)
     import threading