goxoy_p2p/
p2p_fast_connection.rs1use goxoy_address_parser::address_parser::AddressParser;
2use log::{error, info, warn};
3use secp256k1::{ecdsa::Signature, Message, PublicKey, Secp256k1, SecretKey};
4use std::{
5 io::{Read, Write},
6 net::TcpStream,
7 str::FromStr,
8};
9
10use crate::{helpers::digest_for_sign, structs::*};
11
12pub trait SignToNodeP2PPingData {
13 fn sign(&self, private_key: SecretKey) -> String;
14 fn verify(&self, public_key: String) -> bool;
15 fn convert_to_string(&self) -> Message;
16}
17impl SignToNodeP2PPingData for NodeP2PPingData {
18 fn sign(&self, private_key: SecretKey) -> String {
19 let secp_sign = Secp256k1::new();
20 bs58::encode(
21 hex::decode(
22 secp_sign
23 .sign_ecdsa(
24 &self.convert_to_string(),
25 &private_key
26 )
27 .to_string()
28 ).unwrap()
29 ).into_string()
30 }
31 fn verify(&self, public_key: String) -> bool {
32 let secp_verify = Secp256k1::new();
33 let bs58_decode=bs58::decode(public_key.as_bytes()).into_vec();
34 if bs58_decode.is_ok(){
35 let bs58_decode_result=bs58_decode.unwrap();
36 let pub_key_obj = PublicKey::from_str(&hex::encode(bs58_decode_result));
37 if pub_key_obj.is_ok(){
38 let pub_key_obj_result=pub_key_obj.unwrap();
39 let bs_decode=bs58::decode(self.sign.clone().as_bytes()).into_vec();
40 if bs_decode.is_ok(){
41 let bs_decode_result=bs_decode.unwrap();
42 let sign_obj = Signature::from_str(&hex::encode(bs_decode_result));
43 if sign_obj.is_ok(){
44 let sign_obj_result=sign_obj.unwrap();
45 if secp_verify.verify_ecdsa(&self.convert_to_string(), &sign_obj_result, &pub_key_obj_result).is_ok() {
46 true
47 } else {
48 error!("verify - error - control-point-2657 [ {} ]",public_key);
49 false
50 }
51 }else{
52 error!("verify - error - control-point-7163 [ {} ]",public_key);
53 false
54 }
55 }else{
56 error!("verify - error - control-point-5784 [ {} ]",public_key);
57 false
58 }
59 }else{
60 error!("verify - error - control-point-4685 [ {} ]",public_key);
61 false
62 }
63 }else{
64 error!("verify - error - control-point-8745 [ {} ]",public_key);
65 false
66 }
67 }
68 fn convert_to_string(&self) -> Message {
69 Message::from_digest(
70 digest_for_sign(
71 format!("{}:{}:{}:{}:{}",
72 self.exact_time,
73 self.public_key,
74 self.group_hash,
75 self.list_hash,
76 format!("{}:{}:{}",
77 self.waiting_room.addr,
78 self.waiting_room.public_key,
79 self.waiting_room.request_time
80 )
81 )
82 )
83 )
84 }
85}
86
87pub trait SignToNodeMessageDistribution {
88 fn sign(&mut self, private_key: SecretKey);
89 fn verify(&self, public_key: String) -> bool;
90 fn convert_to_string(&self) -> Message;
91}
92impl SignToNodeMessageDistribution for NodeMessageDistribution {
93 fn sign(&mut self, private_key: SecretKey) {
94 let secp_sign = Secp256k1::new();
95 self.sign = bs58::encode(
96 hex::decode(
97 secp_sign
98 .sign_ecdsa(&self.convert_to_string(), &private_key)
99 .to_string()
100 ).unwrap()
101 ).into_string();
102 }
103 fn verify(&self, public_key: String) -> bool {
104 let secp_verify = Secp256k1::new();
105 let bs58_converted= bs58::decode(
106 public_key.as_bytes()
107 ).into_vec();
108 if bs58_converted.is_ok(){
109 let bs58_converted_result=bs58_converted.unwrap();
110 let pub_key_obj = PublicKey::from_str(
111 &hex::encode(bs58_converted_result)
112 );
113 if pub_key_obj.is_ok(){
114 let pub_key_obj_result=pub_key_obj.unwrap();
115 let bs58_decode_str=bs58::decode(self.sign.clone().as_bytes()).into_vec();
116 if bs58_decode_str.is_ok(){
117 let bs58_decode_str_result=bs58_decode_str.unwrap();
118 let sign_obj = Signature::from_str(&hex::encode(bs58_decode_str_result));
119 if sign_obj.is_ok(){
120 let sign_obj_result=sign_obj.unwrap();
121 if secp_verify.verify_ecdsa(&self.convert_to_string(), &sign_obj_result, &pub_key_obj_result).is_ok() {
122 true
123 } else {
124 error!("verify - error - control-point-9054 [ {} ]",public_key);
125 false
126 }
127 }else{
128 error!("verify - error - control-point-4065 [ {} ]",public_key);
129 false
130 }
131 }else{
132 error!("verify - error - control-point-5201 [ {} ]",public_key);
133 false
134 }
135 }else{
136 error!("verify - error - control-point-6058 [ {} ]",public_key);
137 false
138 }
139 }else{
140 error!("verify - error - control-point-2056 [ {} ]",public_key);
141 false
142 }
143 }
144 fn convert_to_string(&self) -> Message {
145 Message::from_digest(
146 digest_for_sign(
147 format!(
148 "{}:{}:{}:{}:{}:{}:{}:{}:{:?}:{}",
149 self.id,
150 self.origin,
151 self.sender,
152 self.count,
153 self.level,
154 self.receiver,
155 self.network_id,
156 self.group_id,
157 self.msg_type,
158 self.data,
159 )
160 )
161 )
162 }
163}
164
165
166pub trait SignToNodeMessagePacket {
167 fn sign(&mut self, private_key: SecretKey);
168 fn verify(&self, public_key: String) -> bool;
169 fn convert_to_string(&self) -> Message;
170}
171impl SignToNodeMessagePacket for NodeMessagePacket {
172 fn sign(&mut self, private_key: SecretKey) {
173 let secp_sign = Secp256k1::new();
174 self.sign = bs58::encode(
175 hex::decode(
176 secp_sign
177 .sign_ecdsa(&self.convert_to_string(), &private_key)
178 .to_string()
179 ).unwrap()
180 ).into_string();
181 }
182 fn verify(&self, public_key: String) -> bool {
183 let secp_verify = Secp256k1::new();
184 let bs58_converted= bs58::decode(
185 public_key.as_bytes()
186 ).into_vec();
187 if bs58_converted.is_ok(){
188 let bs58_converted_result=bs58_converted.unwrap();
189 let pub_key_obj = PublicKey::from_str(
190 &hex::encode(bs58_converted_result)
191 );
192 if pub_key_obj.is_ok(){
193 let pub_key_obj_result=pub_key_obj.unwrap();
194 let bs58_decode_str=bs58::decode(self.sign.clone().as_bytes())
195 .into_vec();
196 if bs58_decode_str.is_ok(){
197 let bs58_decode_str_result=bs58_decode_str.unwrap();
198 let sign_obj = Signature::from_str(&hex::encode(bs58_decode_str_result));
199 if sign_obj.is_ok(){
200 let sign_obj_result=sign_obj.unwrap();
201 if secp_verify.verify_ecdsa(&self.convert_to_string(), &sign_obj_result, &pub_key_obj_result).is_ok() {
202 true
203 } else {
204 error!("verify - error - control-point-4759 [ {} ]",public_key);
205 false
206 }
207 }else{
208 error!("verify - error - control-point-7457 [ {} ]",public_key);
209 false
210 }
211 }else{
212 error!("verify - error - control-point-3547 [ {} ]",public_key);
213 false
214 }
215 }else{
216 error!("verify - error - control-point-9524 [ {} ]",public_key);
217 false
218 }
219 }else{
220 error!("verify - error - control-point-4732 [ {} ]",public_key);
221 false
222 }
223 }
224 fn convert_to_string(&self) -> Message {
225 Message::from_digest(
226 digest_for_sign(
227 format!(
228 "{}:{}:{}:{:?}:{}",
229 self.time,
230 self.public_key,
231 self.network_id,
232 self.msg_type,
233 self.data
234 )
235 )
236 )
237 }
238}
239
240
241pub trait AddressParserToConnection {
242 fn one_time_connection(&self, msg_data: NodeMessagePacket) -> Option<NodeMessagePacket>;
243 fn to_string(&self) -> String;
244}
245
246impl AddressParserToConnection for AddressParser {
247 fn to_string(&self) -> String {
248 AddressParser::object_to_string(self.clone())
249 }
250 fn one_time_connection(&self, msg_data: NodeMessagePacket) -> Option<NodeMessagePacket> {
251 let client_obj = TcpStream::connect(AddressParser::local_addr_for_binding(self.clone()));
252 if client_obj.is_err() {
253 error!("client_obj.is_err()");
254 return None;
255 }
256
257 let mut client = client_obj.unwrap();
258 let blocking_result = client.set_nonblocking(true);
259 if blocking_result.is_err() {
260 error!("failed to initiate non-blocking");
261 return None;
262 }
263
264 let serialized_node_list_clone = serde_json::to_string(&msg_data).unwrap().clone();
265 let writed_result = client.write_all(&serialized_node_list_clone.as_bytes());
266 if writed_result.is_err() {
267 error!("writing to socket failed");
268 return None;
269 }
270 let mut buff = vec![0; 1024 * 32];
271 loop {
272 let income = client.read(&mut buff);
273 if income.is_ok() {
274 let msg = buff.into_iter().take_while(|&x| x != 0).collect::<Vec<_>>();
275 let msg_response = serde_json::from_slice::<NodeMessagePacket>(&msg.clone());
276 if msg_response.is_ok() {
277 let msg_response = msg_response.unwrap();
278 if msg_response.msg_type == NodeMessageType::Unknown {
279 error!("islem hatasi oldu - control-point-01");
280 dbg!(msg_response.clone());
281 return None;
282 }
283 return Some(msg_response);
284 } else {
285 let response = String::from_utf8_lossy(&msg);
286 warn!("control-point-1092");
287 info!("response : {:?}", response.clone());
288 }
289 return None;
290 }
291 }
292 }
293}