1 defmodule Pleroma.Web.Salmon do
6 doc = XML.parse_document(salmon)
8 {:xmlObj, :string, data} = :xmerl_xpath.string('string(//me:data[1])', doc)
9 {:xmlObj, :string, sig} = :xmerl_xpath.string('string(//me:sig[1])', doc)
10 {:xmlObj, :string, alg} = :xmerl_xpath.string('string(//me:alg[1])', doc)
11 {:xmlObj, :string, encoding} = :xmerl_xpath.string('string(//me:encoding[1])', doc)
12 {:xmlObj, :string, type} = :xmerl_xpath.string('string(//me:data[1]/@type)', doc)
15 {:ok, data} = Base.url_decode64(to_string(data), ignore: :whitespace)
16 {:ok, sig} = Base.url_decode64(to_string(sig), ignore: :whitespace)
18 encoding = to_string(encoding)
19 type = to_string(type)
21 [data, type, encoding, alg, sig]
24 # TODO rewrite in with-stile
25 # Make it fetch the key from the saved user if there is one
26 def fetch_magic_key(salmon) do
27 [data, _, _, _, _] = decode(salmon)
28 doc = XML.parse_document(data)
29 uri = XML.string_from_xpath("/entry/author[1]/uri", doc)
31 {:ok, info} = Pleroma.Web.OStatus.gather_user_info(uri)
36 def decode_and_validate(magickey, salmon) do
37 [data, type, encoding, alg, sig] = decode(salmon)
39 signed_text = [data, type, encoding, alg]
40 |> Enum.map(&Base.url_encode64/1)
43 key = decode_key(magickey)
45 verify = :public_key.verify(signed_text, :sha256, sig, key)
54 def decode_key("RSA." <> magickey) do
55 make_integer = fn(bin) ->
56 list = :erlang.binary_to_list(bin)
57 Enum.reduce(list, 0, fn (el, acc) -> (acc <<< 8) ||| el end)
60 [modulus, exponent] = magickey
62 |> Enum.map(&Base.url_decode64!/1)
63 |> Enum.map(make_integer)
65 {:RSAPublicKey, modulus, exponent}
68 def encode_key({:RSAPublicKey, modulus, exponent}) do
69 modulus_enc = :binary.encode_unsigned(modulus) |> Base.url_encode64
70 exponent_enc = :binary.encode_unsigned(exponent) |> Base.url_encode64
72 "RSA.#{modulus_enc}.#{exponent_enc}"
75 def generate_rsa_pem do
76 port = Port.open({:spawn, "openssl genrsa"}, [:binary])
77 {:ok, pem} = receive do
78 {^port, {:data, pem}} -> {:ok, pem}
81 if Regex.match?(~r/RSA PRIVATE KEY/, pem) do
88 def keys_from_pem(pem) do
89 [private_key_code] = :public_key.pem_decode(pem)
90 private_key = :public_key.pem_entry_decode(private_key_code)
91 {:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} = private_key
92 public_key = {:RSAPublicKey, modulus, exponent}
93 {:ok, private_key, public_key}
96 def encode(private_key, doc) do
97 type = "application/atom+xml"
98 encoding = "base64url"
101 signed_text = [doc, type, encoding, alg]
102 |> Enum.map(&Base.url_encode64/1)
105 signature = :public_key.sign(signed_text, :sha256, private_key) |> to_string |> Base.url_encode64
106 doc_base64= doc |> Base.url_encode64
108 # Don't need proper xml building, these strings are safe to leave unescaped
110 <?xml version="1.0" encoding="UTF-8"?>
111 <me:env xmlns:me="http://salmon-protocol.org/ns/magic-env">
112 <me:data type="application/atom+xml">#{doc_base64}</me:data>
113 <me:encoding>#{encoding}</me:encoding>
114 <me:alg>#{alg}</me:alg>
115 <me:sig>#{signature}</me:sig>