comment charger des objets de sécu : certif, clefs, type de chiffrement ..)

Version imprimable

07/03/2011, 12h05
ikuzar

comment charger des objets de sécu : certif, clefs, type de chiffrement ..)
Bonjour,
Dans mon programme, je dois charger des certificats ( clients, serveurs, CA) et les clefs correspondants, le type de chiffrement, etc. J'aimerais savoir quel est la meilleure façon d'indiquer à mon programme l'endroit où se trouvent ces objets ?
Pour l'instant je fais quelque chose de pas propre. Dans mon programme je fais des defines .. :
Code:

1 2 3 #define SERV_CERT_DIR "/home/moi/work/certificats/serveur/" #define SERV_CERT_FILE SERV_CERT_DIR "certs/c1.pem" #define SERV_KEY_FILE SERV_CERT_DIR "keys/k1.pem"
j'ai pensé à MINIINI que je connais pas trop.
http://miniini.tuxfamily.org/doc/html/classINIFile.html

1) quel est l'avantage et l'inconvénient de miniini ?
2) auriez vous d'autre propositions ?

Merci d'avance.
07/03/2011, 20h13
3DArchi

Salut

Citation:

Envoyé par ikuzar

1) quel est l'avantage et l'inconvénient de miniini ?
2) auriez vous d'autre propositions ?

1) Connais pas :(
2) Boost.Program Option
10/03/2011, 16h02
panthere noire

hello
les #define son a éviter a cause des effets de bors...
a la limite utilise plutôt des constantes

Code:

const std::string "valeur"

vu que tu as 2 valeur de type string (char?) tu peux utiliser un tableau peux être
vu que je débute les alternative ne son pas forcement adéquate , par contre pour le #define sa c'est sure :?

Un truc que j'aime bien faire, même si je sais que c'est pas top, c'est faire une classe singleton que j'appelle Registry, et qui est une map de string encapsulée. Ça me sert de pool de variables globales. Je te copie l'interface de mon Registry pour montrer à quoi cela ressemble:

Code:

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
/*! \class              Registry
*  \brief               template variable store
*  \author              RP
*  \version     1.0
*  \date                07/07/2008
*/
 
#ifndef __H_REGISTRY_H__
#define __H_REGISTRY_H__
 
#include <string>
#include <sstream>
#include <map>
#include <iostream>
#include <vector>
 
#include "Tools.h"
 
namespace RLib
{
 
/*!
This is a tool wich permit us to store values. 
\stereoype: singleton
*/
class Registry
{
private:
	//! the map that store registries
	std::map< std::string, std::string > m_regs;
 
	//! unique instance
	static Registry* m_instance;
 
public:
	//! dctor
	virtual ~Registry();
 
	//! get unique instance
	static Registry& Instance();
 
	/**
        *       add a new element
        *       @param   key            the key of the wanted element (its name)
        *       @param   element        the value
        */
	void AddElement( const std::string & key, const std::string & element );
 
	/**
        *       get an element from its key
        *       @param   key            the key of the wanted element (its name)
        *       @return  the element wanted
        */
	template <typename T>
	T GetElement( const std::string & key )
	{
		return Tools::FromString<T>( m_regs[key] );
	}
 
	/**
        *       specialisation of the GetElement template function
        *       @param   key            the key of the wanted element (its name)
        *       @return  the element wanted, returned as a string
        */
	std::string GetElement( const std::string & key )
	{
		return m_regs[key];
	}
 
	/**
        *       push a registry into a stream
        *       @param   key    the key of the wanted element (its name)
        *       @param   ost    output stream
        */
	template <typename T>
	void DumpElement( const std::string & key, std::ostream& ost = std::cout ) const
	{
		ost << key << ": " << GetElement<T>(key) << std::endl;
	}
 
private:
	//! private ctor
	Registry(){}
};
 
} // end namespace RLib
 
#endif //__H_REGISTRY_H__

10/03/2011, 17h52
3DArchi

Citation:

Envoyé par r0d

c'est faire une classe singleton que j'appelle Registry

Manque un politique de (non) copie :

Code:

RLib::Registry une_copie = RLib::Registry::Instance(); // compile OK

Et pour ceux qui passeraient par là (car R0d le connait déjà) : Etes-vous atteint de Singletonite ?