jmanteau » Système

Merge de fichiers KeepassX ou Keepass 1.x (.kdb)

jmanteau — Sat, 28 Jan 2012 13:49:41 +0000

J’ai eu le besoin de merger plusieurs fichiers base de données de Keepass. Si vous ne connaissez pas cet excellent gestionnaire de mot de passe allez faire un tour ici ! Son pendant Linux/Mac OS X est KeepassX compatible avec la branche 1.x de Keepass.

Ce script (rapidement fait) prend plusieurs fichiers d’export XML Keepass (Menu -> Exporter sous -> XML)
et les regroupent sous un fichier. Il prend l’entrée la plus récente en cas de conflit. Il affichera les conflits en sortie console.

La source est disponible ici pour ceux qui veulent la regarder et je l’ai également compilé ici pour ceux qui veulent faire un merge rapide.

Télécharger KeeMerge

Pour l’exécutable, le mettre dans le même dossier que les exports xml puis le lancer.

Il faut ensuite importer le merge.xml dans Keepass. Créer une nouvelle base puis Menu-> Importer -> XML Keepass 1.x.

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

from lxml import etree
import datetime, glob

class Password(object):
def __init__(self, node):
date= node.find("lastmodtime").text
self.lastmodtime= datetime.datetime.strptime(date,"%Y-%m-%dT%H:%M:%S")
self.uuid= node.find("uuid").text
self.username= node.find("username").text
self.password= node.find("password").text
self.title= node.find("title").text
self.node= node

def __hash__(self):
return hash(str(self.title)+str(self.lastmodtime)+str(self.uuid))

def __eq__(self,other):
return self.uuid==other.uuid and self.username==other.username and self.password==other.password and self.title==self.title

def __str__(self):

s = "%s (%s): [%s|%s] - %s" % (self.title,self.uuid,self.username,self.password,self.lastmodtime)
return s

def __repr__(self):

s = "%s (%s): [%s|%s] - %s" % (self.title,self.uuid,self.username,self.password,self.lastmodtime)
return s

def getTree(file):
"""
Give the root and tree of the XML file
"""
parser = etree.XMLParser(strip_cdata=False)
tree = etree.parse(file, parser)
root= tree.getroot()
return tree ,root

def getpasswords(file):
"""
Parse and return all the password of an xml exported by Keepass
"""
tree, root = getTree(file)
elements= []
for e in root:
elements.append(Password(e))
return elements

def main():
# give me your xmls
xmls= glob.glob("*.xml")

# a dict uniq by the uuid of the node
uniquepasswords= dict()

# all your passwords are belong to us
passwords=[pwd for f in xmls for pwd in getpasswords(f)]

# let's go marco
for pwd in passwords:
# do I know you ?
if pwd.uuid in uniquepasswords:
challenger= pwd
champion= uniquepasswords[pwd.uuid]
# If exact match, skips
if challenger != champion:
# challenger modified recently ?
if challenger.lastmodtime > champion.lastmodtime:
print "####"
print "%s" % (challenger)
print "more recent than"
print "%s" % (champion)
print "Challenger wins"
uniquepasswords[pwd.uuid]= challenger
elif challenger.lastmodtime < champion.lastmodtime:
print "####"
print "%s" % (challenger)
print "older than"
print "%s" % (champion)
print "Garbage"
else:
# hello you
uniquepasswords[pwd.uuid]= pwd

# Append xml nodes to root
root= etree.Element("pwlist")
for pwd in uniquepasswords.values():
root.append(pwd.node)

# Write to file
et = etree.ElementTree(root)
et.write("merge.xml", pretty_print=True, xml_declaration=True, encoding='utf-8', standalone='yes')

if __name__ == "__main__":
main()

NCSI ou « connectivité limitée » sous Windows

jmanteau — Tue, 06 Sep 2011 15:13:31 +0000

Depuis Windows Vista et Seven lorsque vous connectez un ordinateur à un réseau filaire ou wifi l’icône vous indique l’état de la connexion: non connecté, connectivité limitée ou accès internet.

Cette information est obtenue avec NCSI ( Network Connectivity Status Indicator ). Cette fonctionnalité fonctionne de la manière suivante:

NCSI effectue une requête DNS sur www.msftncsi.com, puis demande la page http://www.msftncsi.com/ncsi.txt. C’est un fichier texte contenant Microsoft NCSI.
NCSI effectue une requête DNS sur dns.msftncsi.com. Cela résout normalement en 131.107.255.255. Si cette vérification échoue on a un problème de connectivité voire un DNS menteur. Mais cette vérification est le plus souvent utilisée lors d’une authentification requise par une page web (type FreeWifi, NeufWifi ou tout autre hotspot).

La fonction part d’une bonne intention mais on envoie quand même une requête à Microsoft avec son IP … et les logs sont gardés:

IIS logs are stored on the server at www.msftncsi.com. These logs contain the time of each access and the IP address recorded for that access. These IP addresses are not used to identify users, and in many cases, they are the address of a network address translation (NAT) computer or proxy server, not a specific client behind that NAT computer or proxy server.

Source

Si on souhaite désactiver cette fonction on peut le faire dans la base de registre:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\NlaSvc\Parameters\Internet
Under the Internet key, double-click EnableActiveProbing, and then in Value data, type: 0. The default for this value is 1. Setting the value to 0 prevents NCSI from connecting to a site on the Internet during checks for connectivity.

On peut également créer son propre serveur pour utiliser cette fonction en modifiant les entrées du registre correspondantes.

Après recherche on tombe sur des articles plus détaillées comme Super User.

UDP over SSH port forwarding

jmanteau — Sun, 10 Jul 2011 19:42:31 +0000

Il est courant d’utliser les tunnels SSH pour faire transiter divers flux TCP. Cependant on ne peut utiliser le port forwarding directement avec du TCP (exemple du DNS ou SNMP). Ce billet vous montre les étapes à effectuer pour atteindre ce but.

Etapes par étapes

Ouvrir un tunnel SSH avec TCP forward port

Depuis votre machine, se connecter au serveur SSH distant avec l’option -L pour utiliser le port forwarding :

1	local# ssh -L PORT_TCP_LOCAL:localhost:PORT_TCP_DISTANT IP_SERVEUR_SSH

La commande précédente transfère depuis le port_tcp_local de localhost vers le port_tcp_distant de server.

Mise en place de TCP to UDP sur le serveur

Sur le serveur SSH on ouvre un listener sur le port PORT_TCP_DISTANT qui transfèrera les données vers le port UDP du serveur voulu (par exemple dans le cas d’un DNS forwarding l’IP du resolveur DNS).
Avant tout il faut créer un FIFO qui fait office de transfert en local. Une fifo est une communication bidirectionnel entre deux processus. La fifo est à distinguer du pipe qui est unidirectionnel (gauche output vers droit input).

1	server# mkfifo /tmp/fifo

1	server# nc -l -p PORT_TCP_DISTANT < /tmp/fifo \| nc -u IP_SERVEUR_UDP PORT_UDP_DISTANT > /tmp/fifo

Cela permet au trafic TCP du serveur SSH d’être transmis vers le le port du serveur distant portant le service UDP nous intéressant et de transmettre également le retour.

Mise en place du UDP sur TCP sur votre machine

Maintenant nous devons effectuer la manoeuvre opposée sur notre machine.

1	local# mkfifo /tmp/fifo

1	local# sudo nc -l -u -p PORT_UDP_LOCAL < /tmp/fifo \| nc localhost PORT_TCP_LOCAL > /tmp/fifo

Cela permet au trafic UDP provenant du PORT_UDP_LOCAL d’être transféré dans le tunnel SSH écoutant sur le PORT_TCP_LOCAL

Un script pour les lier tous

jmanteau — Tue, 18 May 2010 12:49:16 +0000

MultiCD. Ce petit script est juste superbe.

Il permet de regrouper en une seule iso plusieurs isos distinctes. Le site vous l’expliquera mieux que moi : http://multicd.tuxfamily.org/

Ainsi en gravant une seule ISO vous retrouvez toutes vos distributions facilement.

Pour ma part je vais me faire une ISO avec:

Petites astuces VMware

jmanteau — Thu, 04 Mar 2010 14:06:46 +0000

Accéder au TTYs d’une machine virtuelle Linux/BSD sous VMware Player ou dans une console VMware ESX

Presser CTRL+ALT+ESPACE

relacher ESPACE en maintenant CTRL+ALT

presser F(1-7) pour accéder au tty désiré

Activer le SSH sous ESXi 4 Server

Entrer dans la console ESX avec ALT+F1

Tapez unsupported (rien ne s’affiche, c’est normal) puis Entrée

Entrez ensuite le mot de passe root (attention clavier en qwerty)

Editez avec vi le fichier /etc/inetd.conf:
```
vi /etc/inetd.conf
```

Décommentez le # devant ssh (la ligne avec tcp)

Entrez la commande suivante pour redémarrez les services:
```
services.sh restart
```

Redémarrez également inet avec
```
ps aux |grep inetd
```
pour obtenir le PID puis
```
kill -HUP PID
```