source: n4d-server-plugins/trunk/fuentes/server-install-files/usr/share/n4d/python-plugins/PasswordManager.py @ 8024

Last change on this file since 8024 was 8024, checked in by hectorgh, 14 months ago

shielding password reading plus fixing json unicode error

File size: 3.8 KB
Line 
1# -*- coding: utf-8 -*-
2
3import os
4import shutil
5import json
6import codecs
7
8import sqlite3
9
10class PasswordManager:
11       
12        PASSWORD_FILE="/net/server-sync/var/lib/n4d/n4d.json"
13        LOG_PATH="/net/server-sync/var/lib/n4d"
14       
15        def __init__(self):
16                       
17                self.users={}
18               
19                if not os.path.exists(PasswordManager.LOG_PATH):
20                        os.makedirs(PasswordManager.LOG_PATH)
21               
22                if not os.path.exists("/lib/systemd/system/net-server\\x2dsync.mount"):
23                       
24                        if os.path.exists("/net/server-sync/var/lib/n4d/n4d.sqlite"):
25                                ret=self.sqlite_to_json(True)
26                                if ret:
27                                        os.remove("/net/server-sync/var/lib/n4d/n4d.sqlite")
28                        else:
29                                self.load_password_file()
30                       
31        #def init
32
33       
34        def sqlite_to_json(self,force_write=False):
35               
36                try:
37                        conn = sqlite3.connect("/net/server-sync/var/lib/n4d/n4d.sqlite")
38                        cursor = conn.cursor()
39                        cursor.execute('select cn,sn,uid,passwd from password')
40                        result = cursor.fetchall()
41                        conn.close()
42                       
43                        self.users={}
44                        for user in result :
45                                self.users[user[2]]={}
46                                try:
47                                        self.users[user[2]]["cn"] = user[0].encode('utf-8')
48                                except:
49                                        self.users[user[2]]["cn"] = user[2]
50                                try:
51                                        self.users[user[2]]["sn"] = user[1].encode('utf-8')
52                                except:
53                                        self.users[user[2]]["sn"] = user[2]
54                                try:
55                                        self.users[user[2]]["passwd"] = user[3]
56                                except:
57                                        self.users[user[2]]["passwd"] = "#! UNKNOWN PASSWORD !#"       
58                       
59                        if force_write:
60                                self.write_file()
61                       
62                        return True
63                except Exception as e:
64                        print(e)
65                       
66                        return False
67               
68        #def sqlite_to_json
69       
70               
71        def load_password_file(self, f=None):
72
73                self.users={}
74                if f==None:
75                        f=PasswordManager.PASSWORD_FILE
76                       
77                if not os.path.exists(f):
78                        return False
79               
80                try:
81                        pfile=open(f,"r")
82                        self.users=json.load(pfile)
83                        pfile.close()
84                                                       
85                except Exception as e:
86                        print("[PasswordManager] Error reading file: %s"%e)
87                               
88        #def load_json
89       
90       
91        def write_file(self,f=None):
92               
93                if f==None:
94                        f=PasswordManager.PASSWORD_FILE
95               
96                set_perms=False
97                if not os.path.exists(f):
98                        set_perms=True
99               
100                data=unicode(json.dumps(self.users,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
101                output_file=open(f,"w")
102                output_file.write(data)
103                output_file.close()
104               
105                if set_perms:
106                        prevmask=os.umask(0)
107                        os.chmod(f,0640)
108                        os.umask(prevmask)
109               
110        #def write_file
111
112       
113        def add_password(self,user_name,cn,sn,password):
114               
115                if user_name not in self.users:
116                        self.users[user_name]={}
117               
118                if type(cn)==str:
119                        cn=cn.decode("utf-8")
120                if type(sn)==str:
121                        sn=sn.decode("utf-8")
122       
123                self.users[user_name]["cn"]=cn
124                self.users[user_name]["sn"]=sn
125                self.users[user_name]["passwd"]=password
126               
127                self.write_file()
128               
129        #def add_password
130       
131       
132        def remove_password(self,user_name):
133               
134                if user_name in self.users:
135                        self.users.pop(user_name)
136                       
137                return True
138       
139        #def remove_password
140       
141       
142        def get_passwords(self):
143               
144                pwd_list = []
145                for user in self.users :
146                       
147                        a = {}
148                        try:
149                                a['cn'] = self.users[user]["cn"].encode("UTF-8")
150                        except:
151                                print("[PasswordManager] Error reading user cn %s."%user)
152                                a['cn'] = user
153                               
154                        try:
155                                a['sn'] = self.users[user]["sn"].encode("UTF-8")
156                        except:
157                                print("[PasswordManager] Error reading user sn %s."%user)
158                                a['sn'] =user
159                       
160                        a['uid'] = user
161                        try:
162                                a['passwd'] = self.users[user]["passwd"]
163                        except:
164                                print("[PasswordManager] Error reading user passwd %s."%user)
165                                a['passwd'] = "#! UNKNOWN PASSWORD !#"
166                               
167                        pwd_list.append(a)
168                       
169                       
170
171                return pwd_list
172               
173        #def get_passwords
174       
175       
176        def is_user_in_database(self,uid):
177               
178                for user in self.users:
179                        return True
180                       
181                return False
182               
183        #def is_user_in_database
184       
185       
186        def set_externally_modified(self,uid):
187               
188                if self.is_user_in_database(uid):
189                        self.add_password(uid,self.users[uid]["cn"],self.users[uid]["sn"],"#! CHANGED MANUALLY !#")
190                       
191        #def set_externally_modified   
192       
193       
194#class PasswordManager
195
196if __name__=="__main__":
197       
198        pm=PasswordManager()
199       
200
Note: See TracBrowser for help on using the repository browser.