← Back to branch summary

~mathiaz/+junk/ceph-new-pkg-review

« back to all changes in this revision

Viewing changes to src/auth/cephx/CephxKeyServer.h

  • Committer: Mathias Gug
  • Date: 2010-07-29 03:10:42 UTC
  • Revision ID: mathias.gug@canonical.com-20100729031042-n9n8kky962qb4onb
Import ceph_0.21-0ubuntu1 from https://launchpad.net/~clint-fewbar/+archive/ceph/+packages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/auth/cephx/CephxKeyServer.h
 
1
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- 
 
2
// vim: ts=8 sw=2 smarttab
 
3
/*
 
4
 * Ceph - scalable distributed file system
 
5
 *
 
6
 * Copyright (C) 2004-2009 Sage Weil <sage@newdream.net>
 
7
 *
 
8
 * This is free software; you can redistribute it and/or
 
9
 * modify it under the terms of the GNU Lesser General Public
 
10
 * License version 2.1, as published by the Free Software 
 
11
 * Foundation.  See file COPYING.
 
12
 * 
 
13
 */
 
14
 
 
15
#ifndef CEPH_KEYSSERVER_H
 
16
#define CEPH_KEYSSERVER_H
 
17
 
 
18
#include "config.h"
 
19
 
 
20
#include "auth/KeyRing.h"
 
21
#include "CephxProtocol.h"
 
22
 
 
23
#include "common/Timer.h"
 
24
 
 
25
struct KeyServerData {
 
26
  version_t version;
 
27
 
 
28
  /* for each entity */
 
29
  map<EntityName, EntityAuth> secrets;
 
30
 
 
31
  /* for each service type */
 
32
  version_t rotating_ver;
 
33
  map<uint32_t, RotatingSecrets> rotating_secrets;
 
34
 
 
35
  KeyServerData() : version(0), rotating_ver(0) {}
 
36
 
 
37
  void encode(bufferlist& bl) const {
 
38
     __u8 struct_v = 1;
 
39
    ::encode(struct_v, bl);
 
40
    ::encode(version, bl);
 
41
    ::encode(rotating_ver, bl);
 
42
    ::encode(secrets, bl);
 
43
    ::encode(rotating_secrets, bl);
 
44
  }
 
45
  void decode(bufferlist::iterator& bl) {
 
46
    __u8 struct_v;
 
47
    ::decode(struct_v, bl);
 
48
    ::decode(version, bl);
 
49
    ::decode(rotating_ver, bl);
 
50
    ::decode(secrets, bl);
 
51
    ::decode(rotating_secrets, bl);
 
52
  }
 
53
 
 
54
  void encode_rotating(bufferlist& bl) {
 
55
     __u8 struct_v = 1;
 
56
    ::encode(struct_v, bl);
 
57
    ::encode(rotating_ver, bl);
 
58
    ::encode(rotating_secrets, bl);
 
59
  }
 
60
  void decode_rotating(bufferlist& rotating_bl) {
 
61
    bufferlist::iterator iter = rotating_bl.begin();
 
62
    __u8 struct_v;
 
63
    ::decode(struct_v, iter);
 
64
    ::decode(rotating_ver, iter);
 
65
    ::decode(rotating_secrets, iter);
 
66
  }
 
67
 
 
68
  bool contains(EntityName& name) {
 
69
    return (secrets.find(name) != secrets.end());
 
70
  }
 
71
 
 
72
  void add_auth(const EntityName& name, EntityAuth& auth) {
 
73
    secrets[name] = auth;
 
74
  }
 
75
 
 
76
  void remove_secret(const EntityName& name) {
 
77
    map<EntityName, EntityAuth>::iterator iter = secrets.find(name);
 
78
    if (iter == secrets.end())
 
79
      return;
 
80
    secrets.erase(iter);
 
81
  }
 
82
 
 
83
  bool get_service_secret(uint32_t service_id, ExpiringCryptoKey& secret, uint64_t& secret_id);
 
84
  bool get_service_secret(uint32_t service_id, CryptoKey& secret, uint64_t& secret_id);
 
85
  bool get_service_secret(uint32_t service_id, uint64_t secret_id, CryptoKey& secret);
 
86
  bool get_auth(EntityName& name, EntityAuth& auth);
 
87
  bool get_secret(EntityName& name, CryptoKey& secret);
 
88
  bool get_caps(EntityName& name, string& type, AuthCapsInfo& caps);
 
89
 
 
90
  map<EntityName, EntityAuth>::iterator secrets_begin() { return secrets.begin(); }
 
91
  map<EntityName, EntityAuth>::iterator secrets_end() { return secrets.end(); }
 
92
  map<EntityName, EntityAuth>::iterator find_name(EntityName& name) { return secrets.find(name); }
 
93
 
 
94
 
 
95
  // -- incremental updates --
 
96
  typedef enum {
 
97
    AUTH_INC_NOP,
 
98
    AUTH_INC_ADD,
 
99
    AUTH_INC_DEL,
 
100
    AUTH_INC_SET_ROTATING,
 
101
  } IncrementalOp;
 
102
 
 
103
  struct Incremental {
 
104
    IncrementalOp op;
 
105
    bufferlist rotating_bl;  // if SET_ROTATING.  otherwise,
 
106
    EntityName name;
 
107
    EntityAuth auth;
 
108
    
 
109
    void encode(bufferlist& bl) const {
 
110
      __u8 struct_v = 1;
 
111
      ::encode(struct_v, bl);
 
112
     __u32 _op = (__u32)op;
 
113
      ::encode(_op, bl);
 
114
      if (op == AUTH_INC_SET_ROTATING) {
 
115
        ::encode(rotating_bl, bl);
 
116
      } else {
 
117
        ::encode(name, bl);
 
118
        ::encode(auth, bl);
 
119
      }
 
120
    }
 
121
    void decode(bufferlist::iterator& bl) {
 
122
      __u8 struct_v;
 
123
      ::decode(struct_v, bl);
 
124
      __u32 _op;
 
125
      ::decode(_op, bl);
 
126
      op = (IncrementalOp)_op;
 
127
      assert(op >= AUTH_INC_NOP && op <= AUTH_INC_SET_ROTATING);
 
128
      if (op == AUTH_INC_SET_ROTATING) {
 
129
        ::decode(rotating_bl, bl);
 
130
      } else {
 
131
        ::decode(name, bl);
 
132
        ::decode(auth, bl);
 
133
      }
 
134
    }
 
135
  };
 
136
 
 
137
  void apply_incremental(Incremental& inc) {
 
138
    switch (inc.op) {
 
139
    case AUTH_INC_ADD:
 
140
      add_auth(inc.name, inc.auth);
 
141
      break;
 
142
      
 
143
    case AUTH_INC_DEL:
 
144
      remove_secret(inc.name);
 
145
      break;
 
146
 
 
147
    case AUTH_INC_SET_ROTATING:
 
148
      decode_rotating(inc.rotating_bl);
 
149
      break;
 
150
 
 
151
    case AUTH_INC_NOP:
 
152
      break;
 
153
 
 
154
    default:
 
155
      assert(0);
 
156
    }
 
157
  }
 
158
 
 
159
};
 
160
WRITE_CLASS_ENCODER(KeyServerData);
 
161
WRITE_CLASS_ENCODER(KeyServerData::Incremental);
 
162
 
 
163
 
 
164
 
 
165
 
 
166
class KeyServer : public KeyStore {
 
167
  KeyServerData data;
 
168
 
 
169
  Mutex lock;
 
170
 
 
171
  int _rotate_secret(uint32_t service_id);
 
172
  bool _check_rotating_secrets();
 
173
  void _dump_rotating_secrets();
 
174
  int _build_session_auth_info(uint32_t service_id, CephXServiceTicketInfo& auth_ticket_info, CephXSessionAuthInfo& info);
 
175
  bool _get_service_caps(EntityName& name, uint32_t service_id, AuthCapsInfo& caps);
 
176
public:
 
177
  KeyServer();
 
178
 
 
179
  bool generate_secret(CryptoKey& secret);
 
180
 
 
181
  bool get_secret(EntityName& name, CryptoKey& secret);
 
182
  bool get_auth(EntityName& name, EntityAuth& auth);
 
183
  bool get_caps(EntityName& name, string& type, AuthCapsInfo& caps);
 
184
  bool get_active_rotating_secret(EntityName& name, CryptoKey& secret);
 
185
  int start_server();
 
186
  void rotate_timeout(double timeout);
 
187
 
 
188
  int build_session_auth_info(uint32_t service_id, CephXServiceTicketInfo& auth_ticket_info, CephXSessionAuthInfo& info);
 
189
  int build_session_auth_info(uint32_t service_id, CephXServiceTicketInfo& auth_ticket_info, CephXSessionAuthInfo& info,
 
190
                                        CryptoKey& service_secret, uint64_t secret_id);
 
191
 
 
192
  /* get current secret for specific service type */
 
193
  bool get_service_secret(uint32_t service_id, ExpiringCryptoKey& service_key, uint64_t& secret_id);
 
194
  bool get_service_secret(uint32_t service_id, CryptoKey& service_key, uint64_t& secret_id);
 
195
  bool get_service_secret(uint32_t service_id, uint64_t secret_id, CryptoKey& secret);
 
196
 
 
197
  bool generate_secret(EntityName& name, CryptoKey& secret);
 
198
 
 
199
  void encode(bufferlist& bl) const {
 
200
    ::encode(data, bl);
 
201
  }
 
202
  void decode(bufferlist::iterator& bl) {
 
203
    Mutex::Locker l(lock);
 
204
    ::decode(data, bl);
 
205
  }
 
206
  bool contains(EntityName& name);
 
207
  void list_secrets(stringstream& ss);
 
208
  version_t get_ver() {
 
209
    Mutex::Locker l(lock);
 
210
    return data.version;    
 
211
  }
 
212
 
 
213
  void apply_data_incremental(KeyServerData::Incremental& inc) {
 
214
    data.apply_incremental(inc);
 
215
  }
 
216
  void set_ver(version_t ver) {
 
217
    Mutex::Locker l(lock);
 
218
    data.version = ver;
 
219
  }
 
220
 
 
221
  void add_auth(const EntityName& name, EntityAuth& auth) {
 
222
    Mutex::Locker l(lock);
 
223
    data.add_auth(name, auth);
 
224
  }
 
225
 
 
226
  void remove_secret(const EntityName& name) {
 
227
    Mutex::Locker l(lock);
 
228
    data.remove_secret(name);
 
229
  }
 
230
 
 
231
  /*void add_rotating_secret(uint32_t service_id, ExpiringCryptoKey& key) {
 
232
    Mutex::Locker l(lock);
 
233
    data.add_rotating_secret(service_id, key);
 
234
  }
 
235
  */
 
236
  void clone_to(KeyServerData& dst) {
 
237
    Mutex::Locker l(lock);
 
238
    dst = data;
 
239
  }
 
240
  void export_keyring(KeyRing& keyring) {
 
241
    for (map<EntityName, EntityAuth>::iterator p = data.secrets.begin();
 
242
         p != data.secrets.end();
 
243
         p++) {
 
244
      keyring.add(p->first, p->second);
 
245
    }
 
246
  }
 
247
 
 
248
  bool updated_rotating(bufferlist& rotating_bl, version_t& rotating_ver);
 
249
 
 
250
  bool get_rotating_encrypted(EntityName& name, bufferlist& enc_bl);
 
251
 
 
252
  Mutex& get_lock() { return lock; }
 
253
  bool get_service_caps(EntityName& name, uint32_t service_id, AuthCapsInfo& caps);
 
254
};
 
255
WRITE_CLASS_ENCODER(KeyServer);
 
256
 
 
257
 
 
258
 
 
259
 
 
260
 
 
261
#endif