-
Notifications
You must be signed in to change notification settings - Fork 0
/
authx.sol
237 lines (216 loc) · 8.35 KB
/
authx.sol
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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract verio {
struct node{
address nodeaddress;
string organisation;
string noderpc;
}
node[] public nodes;
//address => hash(Jwt mapping)
struct vote{
uint yesvote;
uint novote;
}
mapping (string=>bytes32) public addjhash;
mapping (bytes32=>address) public jhashadd;
mapping (bytes32=>bytes32) public addidhash;
event Nodeadd(address nodeaddress,string organisation);
mapping (string=>bool) public nodereplacer;
mapping (string=>vote) public nodevote;
mapping (string=>bool) public ifvoted;
mapping (address=>string) public reversenodemap;
mapping (string=>address) public prenodeaddress;
mapping (string=>string) public prenoderpc;
mapping (bytes32=>bool) public votingdone;
constructor(string memory org,string memory noderpc){
nodes.push(node(msg.sender,org,noderpc));
reversenodemap[msg.sender]=org;
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature)
public
pure
returns (address)
{
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
(bytes32 r, bytes32 s, uint8 v) = splitSignature(_signature);
bytes32 prefixedHashMessage = keccak256(abi.encodePacked(prefix, _ethSignedMessageHash));
return ecrecover(prefixedHashMessage, v, r, s);
}
function VerifyMessage(bytes32 _hashedMessage, uint8 _v, bytes32 _r, bytes32 _s) public pure returns (address) {
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 prefixedHashMessage = keccak256(abi.encodePacked(prefix, _hashedMessage));
address signer = ecrecover(prefixedHashMessage, _v, _r, _s);
return signer;
}
function splitSignature(bytes memory sig)
public
pure
returns ( bytes32 r,bytes32 s,uint8 v)
{
require(sig.length == 65, "invalid signature length");
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
}
//getting total numbers of signature(number of signatures)
function tmp(bytes[] memory _signo)public pure returns(uint){
return _signo.length;
}
function genesisnode() external view returns(string memory){
return nodes[0].organisation;
}
function addnode(string memory organisation,bool _vote) external {
string memory _organisation=reversenodemap[msg.sender];
bytes memory isorgempty = bytes(_organisation);
require(prenodeaddress[organisation]!=address(0),"no applicant node");
require(isorgempty.length!=0,"you are not authorized to vote");
require(ifvoted[string(abi.encodePacked(organisation,"$",_organisation))]!=true,"already voted");
if(_vote==false){
nodevote[organisation]=vote(nodevote[organisation].yesvote,nodevote[organisation].novote+1);
ifvoted[string(abi.encodePacked(organisation,"$",_organisation))]=true;
}
if(_vote==true){
nodevote[organisation]=vote(nodevote[organisation].yesvote+1,nodevote[organisation].novote);
ifvoted[string(abi.encodePacked(organisation,"$",_organisation))]=true;
}
if(nodevote[organisation].novote+nodevote[organisation].yesvote==nodes.length){
if(nodevote[organisation].yesvote>=nodevote[_organisation].novote&&nodevote[organisation].yesvote>0){
nodes.push(node(prenodeaddress[organisation],organisation,prenoderpc[organisation]));
nodereplacer[organisation]=true;
reversenodemap[prenodeaddress[organisation]]=organisation;
}
else{
nodereplacer[organisation]=false;
}
}
}
function nodeatindex(uint8 i) external view returns(string memory){
return nodes[i].organisation;
}
function nodecount() external view returns(uint){
return nodes.length;
}
function authxlogin(bytes32 jwthash,address contractadd) external{
require(addidhash[jwthash] == 0,"jwt already used!");
string memory y=string(abi.encodePacked(string(abi.encodePacked(msg.sender)),"$",string(abi.encodePacked(contractadd))));
addjhash[y]=jwthash;
addidhash[jwthash]=bytes32("none");
votingdone[jwthash]=false;
}
function nodeaddreq(string memory organisation,string memory noderpc) external {
for (uint x=0; x<nodes.length; x++)
{
if(keccak256(abi.encodePacked(nodes[x].organisation))==keccak256(abi.encodePacked(organisation))){
revert();
}
}
require(nodereplacer[organisation]==false,"organisation voting pending wait for result to reapply or denied");
emit Nodeadd(msg.sender,organisation);
nodereplacer[organisation]=true;
prenodeaddress[organisation]=msg.sender;
prenoderpc[organisation]=noderpc;
}
function authrsign(bytes32 jwthash,bytes32 whois,bytes[] memory _verifysigno,bytes[] memory _whoissigno) public{
require(votingdone[jwthash]==false,"voting already completed");
require(_verifysigno.length==nodes.length,"Invalid number of verifier signature");
require(_whoissigno.length==nodes.length,"Invalid number of whoissigno signature");
uint jwtvote;
uint whovote;
for(uint i=0; i<nodes.length; i++){
if(nodes[i].nodeaddress==recoverSigner(jwthash, _verifysigno[i])){
jwtvote++;
}
if(nodes[i].nodeaddress==recoverSigner(whois, _whoissigno[i])){
whovote++;
}
}
require(jwtvote>(nodes.length/2),"auth failed jwtvote");
require(whovote>(nodes.length/2),"auth failed whovote");
addidhash[jwthash]=whois;
votingdone[jwthash]=true;
}
function op(string memory organisation) public view returns(uint){
return nodevote[organisation].yesvote;
}
function islogin(address user) external view returns(bool){
string memory y=string(abi.encodePacked(string(abi.encodePacked(user)),"$",string(abi.encodePacked(msg.sender))));
if(addjhash[y]==""){
return false;
}
else{
if(addidhash[addjhash[y]]==bytes32("none")){
return false;
}
else{
return true;
}
}
}
function iflogin(address user) internal view returns(bool){
string memory y=string(abi.encodePacked(string(abi.encodePacked(user)),"$",string(abi.encodePacked(msg.sender))));
if(addjhash[y]==""){
return false;
}
else{
if(addidhash[addjhash[y]]==bytes32("none")){
return false;
}
else{
return true;
}
}
}
function logout() external {
string memory y=string(abi.encodePacked(string(abi.encodePacked(tx.origin)),"$",string(abi.encodePacked(msg.sender))));
require(iflogin(msg.sender)==true,"you are not logged in");
addjhash[y]="";
//addidhash[addjhash[y]]=bytes32("none");
}
function getid(address user) external view returns(bytes32){
string memory y=string(abi.encodePacked(string(abi.encodePacked(user)),"$",string(abi.encodePacked(msg.sender))));
return addidhash[addjhash[y]];
}
// function gg() external view returns(address){
// return msg.sender;
// }
// function tg() external view returns(address){
// return tx.origin;
// }
//function whois(address contractadd) public view
/* just for testing recoverSigner testing
function authsign1(bytes32 jwthash,bytes32 whois,bytes[] memory _verifysigno,bytes[] memory _whoissigno) public pure returns(address){
address na;
na=recoverSigner(jwthash, _verifysigno[0]);
return na;
}
function authsign2(bytes32 jwthash,bytes32 whois,bytes[] memory _verifysigno,bytes[] memory _whoissigno) public pure returns(address){
address na;
na=recoverSigner(jwthash, _verifysigno[1]);
return na;
}
function authsign3(bytes32 jwthash,bytes32 whois,bytes[] memory _verifysigno,bytes[] memory _whoissigno) public pure returns(address){
address na;
na=recoverSigner(whois, _whoissigno[0]);
return na;
}
function authsign4(bytes32 jwthash,bytes32 whois,bytes[] memory _verifysigno,bytes[] memory _whoissigno) public pure returns(address){
address na;
na=recoverSigner(whois, _whoissigno[1]);
return na;
}
function au(bytes32 jw,bytes[] memory x) public returns(address){
address na;
na=recoverSigner(jw,x[0]);
return na;
}
function mv(bytes32 _hashedMessage, uint8 _v, bytes32 _r, bytes32 _s) public pure returns (address) {
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 prefixedHashMessage = keccak256(abi.encodePacked(prefix, _hashedMessage));
address signer = ecrecover(prefixedHashMessage, _v, _r, _s);
return signer;
}
*/
}