Cleaning

Author: kdafriend

src/Commands/ListKeys.hs

@@ -43,4 +43,4 @@ listKeysCommand efc mInd mDeriv= do
     (Right (HDRoot seed mpass), Just ChainWeaver) -> printChainWeaverKeys seed mpass mInd
     (Right (HDRoot seed _), Just KIP) -> printKipKeys seed mInd
     (Right (HDRoot seed mpass), Nothing) -> printChainWeaverKeys seed mpass mInd >> putStrLn "" >> printKipKeys seed mInd
-    (Right (PlainKeyPair _ pub), _) -> printPlainKey pub
+    (Right (SingleKeyPair _ pub), _) -> printPlainKey pub

src/Commands/Sign.hs

@@ -86,7 +86,7 @@ signYamlFile kkey mindex enc msgFile = do
           signingKeys = S.fromList $ map _s_pubKey $ unSignatureList sigs
       case kkey of
         HDRoot seed mpass -> tryHdIndex msgFile csd seed mpass mindex
-        PlainKeyPair sec pub -> do
+        SingleKeyPair sec pub -> do
           let pubHex = PublicKeyHex $ pubKeyToText pub
           if S.member pubHex signingKeys
             then do
@@ -160,7 +160,7 @@ signOther msgFile kkey kind enc = do
           HDRoot seed mpass ->
             let (esec, pub) = generateCryptoPairFromRoot (seedToRoot seed mpass) mpass kind
             in (pub, sign esec mpass msg)
-          PlainKeyPair sec pub -> (pub, sign sec Nothing msg)
+          SingleKeyPair sec pub -> (pub, sign sec Nothing msg)
     lift $ T.putStrLn $ pubKeyToText pubKey <> ": " <> coerce sig
   case res of
     Left e -> die e

src/Keys.hs

@@ -48,6 +48,28 @@ import           Utils
 import Data.Base16.Types (extractBase16)
 ------------------------------------------------------------------------------
 
+newtype MnemonicPhrase = MnemonicPhrase [ Text ]
+  deriving (Show, Eq)
+
+data SecretKey = CardanoSecretKey Crypto.XPrv
+               | PlainSecretKey ED25519.SecretKey
+
+data PublicKey = CardanoPublicKey ByteString
+               | PlainPublicKey ED25519.PublicKey
+  deriving (Eq, Show)
+
+
+newtype Signature = Signature Text
+  deriving (Eq, Ord, Show)
+
+newtype ParsedSignature = ParsedSignature ByteString
+  deriving (Eq, Ord, Show)
+
+data KadenaKey
+  = HDRoot ByteString (Maybe Text) --Seed + Maybe Chaibnweaver password
+  | SingleKeyPair SecretKey PublicKey
+
+
 mnemonicToRoot :: MnemonicPhrase -> Crypto.XPrv
 mnemonicToRoot phrase = seedToRoot (phraseToSeed phrase) Nothing -- TODO: Empty passowrd
 
@@ -56,14 +78,20 @@ genMnemonic12 = liftIO $ bimap tshow Crypto.entropyToWords . Crypto.toEntropy @1
   -- This size must be a 1/8th the size of the 'toEntropy' size: 128 / 8 = 16
   <$> Crypto.Random.Entropy.getEntropy @ByteString 16
 
+slip10modifier :: ByteString
+slip10modifier = "ed25519 seed"
+
+kadenaChainCode :: Word32
+kadenaChainCode = 626
+
 -- KIP-0026 / SLIP-10 derivation
 kipDerivSecretKey :: ByteString -> KeyIndex -> ED25519.SecretKey
 kipDerivSecretKey seed ki = onCryptoFailure (error . show) id $ ED25519.secretKey pkey3
   where
     (pkey3, _)     = doDeriv pkey2 code2 (fromKeyIndex ki)
-    (pkey2, code2) = doDeriv pkey1 code1 626
+    (pkey2, code2) = doDeriv pkey1 code1 kadenaChainCode
     (pkey1, code1) = doDeriv pkey0 code0 44
-    (pkey0, code0) = doHmac "ed25519 seed" seed
+    (pkey0, code0) = doHmac slip10modifier seed
 
     doDeriv:: ByteString -> ByteString -> Word32 -> (ByteString, ByteString)
     doDeriv pkey code idx = doHmac code $ LBS.toStrict $  runPut $ putWord8 0 >> putByteString pkey >> putWord32be (0x80000000 .|. idx)
@@ -76,11 +104,13 @@ generateKipCryptoPairFromSeed :: ByteString -> KeyIndex -> (SecretKey, PublicKey
 generateKipCryptoPairFromSeed seed ki = let skey = kipDerivSecretKey seed ki
                                         in (PlainSecretKey skey , PlainPublicKey $ ED25519.toPublic skey)
 
+encodePass :: Maybe Text -> ByteString
+encodePass = T.encodeUtf8 . fromMaybe ""
 
 generateCryptoPairFromRoot :: Crypto.XPrv -> Maybe Text -> KeyIndex -> (SecretKey, PublicKey)
 generateCryptoPairFromRoot root pass i =
   let hardenedIdx = 0x80000000 .|. (fromKeyIndex i)
-      xprv = Crypto.deriveXPrv scheme (T.encodeUtf8 $ fromMaybe "" pass) root hardenedIdx
+      xprv = Crypto.deriveXPrv scheme (encodePass pass) root hardenedIdx
   in (CardanoSecretKey xprv, CardanoPublicKey $ Crypto.xpubPublicKey $ Crypto.toXPub xprv)
   where
     scheme = Crypto.DerivationScheme2
@@ -93,10 +123,6 @@ mkPhraseMapFromMnemonic
 mkPhraseMapFromMnemonic = wordsToPhraseMap . T.words . baToText
   . Crypto.mnemonicSentenceToString @mw Crypto.english
 
-newtype MnemonicPhrase = MnemonicPhrase [ Text ]
-  deriving (Show, Eq)
-
--- TODO Allow 24-word phrases
 mkMnemonicPhrase :: [Text] -> Maybe MnemonicPhrase
 mkMnemonicPhrase lst
   | length lst == 12 = Just $ MnemonicPhrase lst
@@ -150,7 +176,7 @@ sentenceToSeed s = Crypto.sentenceToSeed s Crypto.english ""
 -- unlocked with the password
 -- TODO: enter password 2x, to confirm
 seedToRoot :: ByteArrayAccess ba => ba -> Maybe Text -> Crypto.XPrv
-seedToRoot seed password = Crypto.generate seed $ T.encodeUtf8 $ fromMaybe "" password
+seedToRoot seed password = Crypto.generate seed $ encodePass password
 
 -- | Convenience function for unpacking byte array things into 'Text'
 newtype WordKey = WordKey { _unWordKey :: Int }
@@ -159,10 +185,6 @@ newtype WordKey = WordKey { _unWordKey :: Int }
 wordsToPhraseMap :: [Text] -> Map.Map WordKey Text
 wordsToPhraseMap = Map.fromList . zip [WordKey 1 ..]
 
-data KadenaKey
-  = HDRoot ByteString (Maybe Text) --Seed + Maybe Chaibnweaver password
-  | PlainKeyPair SecretKey PublicKey
-
 data KeyPairYaml = KeyPairYaml
   { kpyPublic :: Text
   , kpySecret :: Text
@@ -188,7 +210,7 @@ readKadenaKey h = do
         let mres = do
               pub <- maybeCryptoError . ED25519.publicKey =<< hush (fromB16 $ kpyPublic kpy)
               sec <- maybeCryptoError . ED25519.secretKey =<< hush (fromB16 $ kpySecret kpy)
-              pure $ PlainKeyPair (PlainSecretKey sec) (PlainPublicKey pub)
+              pure $ SingleKeyPair (PlainSecretKey sec) (PlainPublicKey pub)
         pure $ note "not a valid ED25519 key pair" mres
     Right _ -> pure $ Left "Invalid JSON type for key material"
     Left _ -> pure $ Left "Could not parse key material"
@@ -221,21 +243,6 @@ genPairFromPhrase :: MnemonicPhrase -> KeyIndex -> (SecretKey, PublicKey)
 genPairFromPhrase phrase idx =
   generateCryptoPairFromRoot (mnemonicToRoot phrase) Nothing idx
 
-
-data SecretKey = CardanoSecretKey Crypto.XPrv
-               | PlainSecretKey ED25519.SecretKey
-
-data PublicKey = CardanoPublicKey ByteString
-               | PlainPublicKey ED25519.PublicKey
-  deriving (Eq, Show)
-
-
-newtype Signature = Signature Text
-  deriving (Eq, Ord, Show)
-
-newtype ParsedSignature = ParsedSignature ByteString
-  deriving (Eq, Ord, Show)
-
 parseSignature :: Text -> Either Text ParsedSignature
 parseSignature x = do
   bs <- fromB16 x
@@ -256,7 +263,7 @@ toPubKey txt = do
 
 
 sign :: SecretKey -> Maybe Text -> ByteString -> Signature
-sign (CardanoSecretKey xprv) mpass = Signature . toB16 . Crypto.unXSignature . Crypto.sign @ByteString (T.encodeUtf8 (fromMaybe "" mpass)) xprv
+sign (CardanoSecretKey xprv) mpass = Signature . toB16 . Crypto.unXSignature . Crypto.sign @ByteString (encodePass mpass) xprv
 sign (PlainSecretKey xprv) _ = Signature . toB16 . BA.convert . ED25519.sign xprv (ED25519.toPublic xprv)
 
 verify :: PublicKey -> ParsedSignature -> ByteString -> Bool