1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
# Copyright 2009-2011 Canonical Ltd. This software is licensed under the
# GNU Affero General Public License version 3 (see the file LICENSE).
# pylint: disable-msg=E0211,E0213
"""OpenPGP key interfaces."""
__metaclass__ = type
__all__ = [
'IGPGKey',
'IGPGKeySet',
'GPGKeyAlgorithm',
'valid_keyid',
'valid_fingerprint',
]
import re
from lazr.enum import (
DBEnumeratedType,
DBItem,
)
from lazr.restful.declarations import (
export_as_webservice_entry,
exported,
)
from zope.interface import (
Attribute,
Interface,
)
from zope.schema import (
Bool,
Choice,
Int,
TextLine,
)
from lp import _
from lp.registry.interfaces.role import IHasOwner
def valid_fingerprint(fingerprint):
"""Is the fingerprint of valid form."""
# Fingerprints of v3 keys are md5, fingerprints of v4 keys are sha1;
# accordingly, fingerprints of v3 keys are 128 bit, those of v4 keys
# 160. Check therefore for strings of hex characters that are 32
# (4 * 32 == 128) or 40 characters long (4 * 40 = 160).
if len(fingerprint) not in (32, 40):
return False
if re.match(r"^[\dA-F]+$", fingerprint) is None:
return False
return True
def valid_keyid(keyid):
"""Is the key of valid form."""
if re.match(r"^[\dA-F]{8}$", keyid) is not None:
return True
else:
return False
# XXX: cprov 2004-10-04:
# (gpg+dbschema) the data structure should be rearranged to support 4 field
# needed: keynumber(1,16,17,20), keyalias(R,g,D,G), title and description
class GPGKeyAlgorithm(DBEnumeratedType):
"""
GPG Compliant Key Algorithms Types:
1 : "R", # RSA
16: "g", # ElGamal
17: "D", # DSA
20: "G", # ElGamal, compromised
FIXME
Rewrite it according to the experimental API returning also a name
attribute tested on 'algorithmname' attribute
"""
R = DBItem(1, """
R
RSA""")
LITTLE_G = DBItem(16, """
g
ElGamal""")
D = DBItem(17, """
D
DSA""")
G = DBItem(20, """
G
ElGamal, compromised""")
class IGPGKey(IHasOwner):
"""OpenPGP support"""
export_as_webservice_entry('gpg_key')
id = Int(title=_("Database id"), required=True, readonly=True)
keysize = Int(title=_("Keysize"), required=True)
algorithm = Choice(title=_("Algorithm"), required=True,
vocabulary='GpgAlgorithm')
keyid = exported(
TextLine(title=_("OpenPGP key ID"), required=True,
constraint=valid_keyid, readonly=True))
fingerprint = exported(
TextLine(title=_("User Fingerprint"), required=True,
constraint=valid_fingerprint, readonly=True))
active = Bool(title=_("Active"), required=True)
displayname = Attribute("Key Display Name")
keyserverURL = Attribute(
"The URL to retrieve this key from the keyserver.")
can_encrypt = Bool(title=_("Key can be used for encryption"),
required=True)
owner = Int(title=_('Person'), required=True, readonly=True)
ownerID = Int(title=_('Owner ID'), required=True, readonly=True)
class IGPGKeySet(Interface):
"""The set of GPGKeys."""
def new(ownerID, keyid, fingerprint, keysize,
algorithm, active=True, can_encrypt=True):
"""Create a new GPGKey pointing to the given Person."""
def activate(requester, key, can_encrypt):
"""Activate 'key' for 'requester'.
:return: A tuple of (IGPGKey, new), where 'new' is False if we have
reactivated an existing key.
"""
def get(key_id, default=None):
"""Return the GPGKey object for the given id.
Return the given default if there's no object with the given id.
"""
def getByFingerprint(fingerprint, default=None):
"""Return UNIQUE result for a given Key fingerprint including
inactive ones.
"""
def getGPGKeys(ownerid=None, active=True):
"""Return OpenPGP keys ordered by id.
Optionally for a given owner and or a given status.
"""
def getGPGKeysForPeople(people):
"""Return OpenPGP keys for a set of people."""
|