Ed25519 support.

4 files changed, 84 insertions, 14 deletions

diff --git a/Data/OpenPGP/Internal.hs b/Data/OpenPGP/Internal.hs
index 175a62e..f9a8803 100644
--- a/Data/OpenPGP/Internal.hs
+++ b/Data/OpenPGP/Internal.hs
@@ -16,20 +16,20 @@ import           System.IO.Unsafe
 
 
 decode_s2k_count :: Word8 -> Word32
-decode_s2k_count c =  (16 + (fromIntegral c .&. 15)) `shiftL`
-        ((fromIntegral c `shiftR` 4) + 6)
+decode_s2k_count c = shiftL (16 + (fromIntegral c .&. 15))
+                            ((fromIntegral c `shiftR` 4) + 6)
 
 encode_s2k_count :: Word32 -> Word8
 encode_s2k_count iterations
-        | iterations >= 65011712 = 255
-        | decode_s2k_count result < iterations = result+1
-        | otherwise = result
-        where
-        result = fromIntegral $ (fromIntegral c `shiftL` 4) .|. (count - 16)
-        (count, c) = encode_s2k_count' (iterations `shiftR` 6) (0::Word8)
-        encode_s2k_count' count c
-                | count < 32 = (count, c)
-                | otherwise = encode_s2k_count' (count `shiftR` 1) (c+1)
+    | iterations >= 65011712 = 255
+    | decode_s2k_count result < iterations = result+1
+    | otherwise = result
+    where
+    result = fromIntegral $ (fromIntegral c `shiftL` 4) .|. (count - 16)
+    (count, c) = encode_s2k_count' (iterations `shiftR` 6) (0::Word8)
+    encode_s2k_count' count c
+        | count < 32 = (count, c)
+        | otherwise = encode_s2k_count' (count `shiftR` 1) (c+1)
 
 {-
 getBigNum :: BS.ByteString -> Integer
@@ -70,8 +70,26 @@ putBigNum i = ( (fromIntegral (BS.length bytes) - 1) * 8 + sigBit
     sigBit = fromIntegral $ 8 - countLeadingZeros (BS.index bytes 0)
     bytes = integerToBS i
 
+-- big-endian
 integerToBS :: Integer -> BS.ByteString
 integerToBS i = BS.unsafeCreate (I# (word2Int# (sizeInBaseInteger i 256#))) $ \ptr -> do
         let Ptr addr = ptr
-        cnt <- exportIntegerToAddr i addr 1#
+        cnt <- exportIntegerToAddr i addr 1# -- 1# for big-endian (use 0# for little-endian)
         return ()
+
+{-
+getBigNumLE :: BS.ByteString -> Integer
+getBigNumLE bytes = unsafeDupablePerformIO $
+    let (fptr,offset,len) = BS.toForeignPtr bytes
+    in withForeignPtr fptr $ \ptr -> do
+        let Ptr addr = ptr `plusPtr` offset :: Ptr Word64
+            I# n = len
+        importIntegerFromAddr addr (int2Word# n) 0#
+
+-- little-endian
+integerToLE :: Integer -> BS.ByteString
+integerToLE i = BS.unsafeCreate (I# (word2Int# (sizeInBaseInteger i 256#))) $ \ptr -> do
+        let Ptr addr = ptr
+        cnt <- exportIntegerToAddr i addr 0#
+        return ()
+-}
diff --git a/Data/OpenPGP/Util/Base.hs b/Data/OpenPGP/Util/Base.hs
index 5b3e159..0c888ca 100644
--- a/Data/OpenPGP/Util/Base.hs
+++ b/Data/OpenPGP/Util/Base.hs
@@ -85,7 +85,6 @@ find_key :: OpenPGP.Message -> String -> Maybe OpenPGP.Packet
 find_key = OpenPGP.find_key (show . fingerprint)
 
 
-
 keyParam :: Char -> OpenPGP.Packet -> Integer
 keyParam c k = fromJustMPI $ lookup c (OpenPGP.key k)
  where
diff --git a/Data/OpenPGP/Util/Ed25519.hs b/Data/OpenPGP/Util/Ed25519.hs
new file mode 100644
index 0000000..ed277c8
--- /dev/null
+++ b/Data/OpenPGP/Util/Ed25519.hs
@@ -0,0 +1,51 @@
+module Data.OpenPGP.Util.Ed25519 where
+
+import Crypto.Error
+import qualified Crypto.PubKey.Ed25519 as Ed25519
+import Data.OpenPGP.Internal -- (integerToBS,integerToLE,getBigNumLE)
+import qualified Data.OpenPGP as OpenPGP
+import Crypto.ECC.Edwards25519
+
+import qualified Data.ByteArray as BA
+import Control.Monad
+import qualified Data.ByteString as BS
+import qualified Data.ByteString.Lazy as BL
+import Data.List
+import Data.Int
+import Data.Word
+import Data.OpenPGP.Util.Base
+
+import Text.Printf
+import Numeric
+import Data.Char
+import System.IO
+
+import Foreign.Ptr
+import System.IO.Unsafe
+
+import Crypto.Cipher.SBox
+
+ed25519Key :: OpenPGP.Packet -> Maybe Ed25519.PublicKey
+ed25519Key k = case Ed25519.publicKey $ integerToBS $ keyParam 'n' k of
+    CryptoPassed ed25519 -> Just ed25519
+    CryptoFailed err     -> Nothing
+
+ed25519sig sig =
+    let [OpenPGP.MPI r,OpenPGP.MPI s] = OpenPGP.signature sig
+        -- rbs = BS.pack $ take 32 $ rbytes r ++ repeat 0
+        -- sbs = BS.pack $ take 32 $ rbytes s ++ repeat 0
+        rbs = let r' = integerToBS r in BS.replicate (32 - BS.length r') 0 <> r'
+        sbs = let s' = integerToBS s in BS.replicate (32 - BS.length s') 0 <> s'
+    in case Ed25519.signature (rbs <> sbs) of
+        CryptoPassed sig -> Just sig
+        CryptoFailed err -> Nothing
+
+ed25519Verify :: OpenPGP.Packet -> BS.ByteString -> OpenPGP.Packet -> Maybe Bool
+ed25519Verify sig over k = do
+    let hashbs = hashBySymbol (OpenPGP.hash_algorithm sig) $ BL.fromChunks [over]
+    guard $ 0x2B06010401DA470F01 == keyParam 'c' k -- Only Ed25519 curve.
+    k' <- ed25519Key k -- SecretKeyPacket ???
+    sig' <- ed25519sig sig
+    let result = Ed25519.verify k' hashbs sig'
+    Just result
+
diff --git a/Data/OpenPGP/Util/Verify.hs b/Data/OpenPGP/Util/Verify.hs
index fd83485..5eea260 100644
--- a/Data/OpenPGP/Util/Verify.hs
+++ b/Data/OpenPGP/Util/Verify.hs
@@ -19,6 +19,7 @@ import Crypto.PubKey.HashDescr
 #endif
 
 import Data.OpenPGP.Util.Base
+import Data.OpenPGP.Util.Ed25519
 
 
 dsaKey :: OpenPGP.Packet -> Vincent.DSA.PublicKey
@@ -43,6 +44,7 @@ verify ::
 verify keys over =
     over {OpenPGP.signatures_over = mapMaybe (uncurry $ verifyOne keys) sigs}
     where
+    sigs :: [(OpenPGP.Packet,BS.ByteString)]
     sigs = map (\s -> (s, toStrictBS $ encode over `LZ.append` OpenPGP.trailer s))
         (OpenPGP.signatures_over over)
 
@@ -52,6 +54,7 @@ verifyOne keys sig over = fmap (const sig) $ maybeKey >>= verification >>= guard
     verification = case OpenPGP.key_algorithm sig of
         OpenPGP.DSA -> dsaVerify
         OpenPGP.ECDSA -> ecdsaVerify
+        OpenPGP.Ed25519 -> ed25519Verify sig over
         alg | alg `elem` [OpenPGP.RSA,OpenPGP.RSA_S] -> rsaVerify
             | otherwise -> const Nothing
 
@@ -97,4 +100,3 @@ verifyOne keys sig over = fmap (const sig) $ maybeKey >>= verification >>= guard
     hash_algo = OpenPGP.hash_algorithm sig
     maybeKey = OpenPGP.signature_issuer sig >>= find_key keys
                -- in trace ("maybeKey="++show (fmap OpenPGP.key_algorithm r)) r
-