Repository navigation
Expand file tree
/
Copy pathFileStorageV2.sol
More file actions
374 lines (304 loc) · 14.4 KB
/
Copy pathFileStorageV2.sol
File metadata and controls
374 lines (304 loc) · 14.4 KB
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
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract FileStorageV3 {
struct FileInfo {
address owner;
string fileHash;
address[] authorizedUsers;
mapping(address => string) encryptedKeys;
string status; // "active", "deleted", "renamed"
uint256 lastModified;
bool exists;
}
mapping(uint256 => FileInfo) public files;
uint256 public fileCount;
// Events for audit trail
event FileUploaded(uint256 indexed fileId, address indexed owner, string fileHash);
event FileDeleted(uint256 indexed fileId, address indexed owner);
event FileRenamed(uint256 indexed fileId, address indexed owner, string newHash);
event AccessGranted(uint256 indexed fileId, address indexed user);
event AccessRevoked(uint256 indexed fileId, address indexed user);
modifier onlyFileOwner(uint256 _fileId) {
require(files[_fileId].owner == msg.sender, "Only file owner can perform this action");
_;
}
modifier fileExists(uint256 _fileId) {
require(files[_fileId].exists, "File does not exist");
_;
}
function uploadFile(
string memory _fileHash,
address[] memory _users,
string[] memory _encryptedKeys,
bool _isEmergencyAccessible
) public {
require(_users.length == _encryptedKeys.length, "Users and keys length mismatch");
uint256 fileId = fileCount;
FileInfo storage newFile = files[fileId];
newFile.owner = msg.sender;
newFile.fileHash = _fileHash;
newFile.authorizedUsers = _users;
newFile.status = "active";
newFile.lastModified = block.timestamp;
newFile.exists = true;
// Store encrypted keys for each user
for (uint256 i = 0; i < _users.length; i++) {
newFile.encryptedKeys[_users[i]] = _encryptedKeys[i];
}
// Handle emergency access
if (_isEmergencyAccessible) {
isEmergencyFile[fileId] = true;
// Auto-grant access to all user's emergency responders
address[] memory responders = userRespondersList[msg.sender];
for (uint256 i = 0; i < responders.length; i++) {
// Check if responder is not already in authorized users list
bool alreadyAuthorized = false;
for (uint256 j = 0; j < newFile.authorizedUsers.length; j++) {
if (newFile.authorizedUsers[j] == responders[i]) {
alreadyAuthorized = true;
break;
}
}
if (!alreadyAuthorized) {
newFile.authorizedUsers.push(responders[i]);
newFile.encryptedKeys[responders[i]] = _encryptedKeys[0]; // Use same key as owner
}
}
emit EmergencyFileMarked(fileId, msg.sender);
}
emit FileUploaded(fileId, msg.sender, _fileHash);
fileCount++;
}
function deleteFile(uint256 _fileId)
external
fileExists(_fileId)
onlyFileOwner(_fileId)
{
files[_fileId].status = "deleted";
files[_fileId].lastModified = block.timestamp;
emit FileDeleted(_fileId, msg.sender);
}
function updateFileHash(uint256 _fileId, string memory _newHash)
external
fileExists(_fileId)
onlyFileOwner(_fileId)
{
require(keccak256(bytes(files[_fileId].status)) == keccak256(bytes("active")), "File is not active");
files[_fileId].fileHash = _newHash;
files[_fileId].status = "renamed";
files[_fileId].lastModified = block.timestamp;
emit FileRenamed(_fileId, msg.sender, _newHash);
}
function grantAccess(uint256 _fileId, address _user, string memory _encryptedKey)
external
fileExists(_fileId)
onlyFileOwner(_fileId)
{
require(keccak256(bytes(files[_fileId].status)) == keccak256(bytes("active")), "File is not active");
require(!hasAccess(_fileId, _user) || files[_fileId].owner == _user, "User already has access");
// Only add to array if not already present (and not owner)
if (files[_fileId].owner != _user) {
files[_fileId].authorizedUsers.push(_user);
}
files[_fileId].encryptedKeys[_user] = _encryptedKey;
files[_fileId].lastModified = block.timestamp;
emit AccessGranted(_fileId, _user);
}
function revokeAccess(uint256 _fileId, address _user)
public
fileExists(_fileId)
onlyFileOwner(_fileId)
{
require(_user != files[_fileId].owner, "Cannot revoke access from file owner");
// Remove ALL occurrences from authorized users array (fix for duplicates)
address[] storage users = files[_fileId].authorizedUsers;
uint256 writeIndex = 0;
for (uint256 i = 0; i < users.length; i++) {
if (users[i] != _user) {
users[writeIndex] = users[i];
writeIndex++;
}
}
// Resize array to remove duplicates
while (users.length > writeIndex) {
users.pop();
}
// Clear encrypted key
delete files[_fileId].encryptedKeys[_user];
files[_fileId].lastModified = block.timestamp;
emit AccessRevoked(_fileId, _user);
}
function getFile(uint256 _id) public view returns (string memory, string memory) {
require(files[_id].exists, "File does not exist");
require(keccak256(bytes(files[_id].status)) != keccak256(bytes("deleted")), "File has been deleted");
require(hasAccess(_id, msg.sender), "Access denied");
return (files[_id].fileHash, files[_id].encryptedKeys[msg.sender]);
}
function getFileStatus(uint256 _fileId) external view returns (string memory, uint256) {
require(files[_fileId].exists, "File does not exist");
return (files[_fileId].status, files[_fileId].lastModified);
}
function hasAccess(uint256 _fileId, address _user) public view returns (bool) {
if (files[_fileId].owner == _user) {
return true;
}
address[] memory authorizedUsers = files[_fileId].authorizedUsers;
for (uint256 i = 0; i < authorizedUsers.length; i++) {
if (authorizedUsers[i] == _user) {
return true;
}
}
return false;
}
// Emergency access system
mapping(address => mapping(address => bool)) public userEmergencyResponders; // user => responder => authorized
mapping(address => address[]) public userRespondersList; // user => list of their responders
mapping(address => mapping(address => string)) public userResponderNicknames; // user => responder => nickname
mapping(uint256 => bool) public isEmergencyFile; // fileId => is emergency accessible
// Events for emergency access
event EmergencyResponderAdded(address indexed user, address indexed responder, string nickname);
event EmergencyResponderRemoved(address indexed user, address indexed responder);
event EmergencyFileMarked(uint256 indexed fileId, address indexed owner);
event EmergencyFileUnmarked(uint256 indexed fileId, address indexed owner);
// User manages their own emergency responders
function addEmergencyResponder(address _responder, string memory _nickname) external {
require(_responder != msg.sender, "Cannot add yourself as emergency responder");
require(!userEmergencyResponders[msg.sender][_responder], "Already added as emergency responder");
require(bytes(_nickname).length > 0, "Nickname cannot be empty");
require(bytes(_nickname).length <= 50, "Nickname too long (max 50 characters)");
userEmergencyResponders[msg.sender][_responder] = true;
userRespondersList[msg.sender].push(_responder);
userResponderNicknames[msg.sender][_responder] = _nickname;
emit EmergencyResponderAdded(msg.sender, _responder, _nickname);
}
function removeEmergencyResponder(address _responder) external {
require(userEmergencyResponders[msg.sender][_responder], "Not an emergency responder");
userEmergencyResponders[msg.sender][_responder] = false;
// Remove nickname
delete userResponderNicknames[msg.sender][_responder];
// Remove ALL occurrences from list (fix for potential duplicates)
address[] storage responders = userRespondersList[msg.sender];
uint256 writeIndex = 0;
for (uint256 i = 0; i < responders.length; i++) {
if (responders[i] != _responder) {
responders[writeIndex] = responders[i];
writeIndex++;
}
}
// Resize array to remove duplicates
while (responders.length > writeIndex) {
responders.pop();
}
emit EmergencyResponderRemoved(msg.sender, _responder);
}
function getMyEmergencyResponders() external view returns (address[] memory) {
return userRespondersList[msg.sender];
}
function isMyEmergencyResponder(address _responder) external view returns (bool) {
return userEmergencyResponders[msg.sender][_responder];
}
function getEmergencyRespondersFor(address _user) external view returns (address[] memory) {
return userRespondersList[_user];
}
// Mark existing file as emergency accessible
function markFileAsEmergency(uint256 _fileId) external fileExists(_fileId) onlyFileOwner(_fileId) {
require(!isEmergencyFile[_fileId], "File already marked as emergency");
isEmergencyFile[_fileId] = true;
// Grant access to all user's emergency responders (only if they don't already have access)
address[] memory responders = userRespondersList[msg.sender];
for (uint256 i = 0; i < responders.length; i++) {
if (!hasAccess(_fileId, responders[i])) {
files[_fileId].authorizedUsers.push(responders[i]);
files[_fileId].encryptedKeys[responders[i]] = files[_fileId].encryptedKeys[msg.sender];
}
}
emit EmergencyFileMarked(_fileId, msg.sender);
}
// Remove emergency access from file
function unmarkFileAsEmergency(uint256 _fileId) external fileExists(_fileId) onlyFileOwner(_fileId) {
require(isEmergencyFile[_fileId], "File not marked as emergency");
isEmergencyFile[_fileId] = false;
// Remove access from all emergency responders
address[] memory responders = userRespondersList[msg.sender];
for (uint256 i = 0; i < responders.length; i++) {
revokeAccess(_fileId, responders[i]);
}
emit EmergencyFileUnmarked(_fileId, msg.sender);
}
// Get files where I have emergency access
function getEmergencyAccessibleFiles() external view returns (uint256[] memory) {
uint256[] memory emergencyFiles = new uint256[](fileCount);
uint256 count = 0;
for (uint256 i = 0; i < fileCount; i++) {
if (files[i].exists &&
isEmergencyFile[i] &&
hasAccess(i, msg.sender) &&
userEmergencyResponders[files[i].owner][msg.sender]) {
emergencyFiles[count] = i;
count++;
}
}
// Resize array to actual count
uint256[] memory result = new uint256[](count);
for (uint256 i = 0; i < count; i++) {
result[i] = emergencyFiles[i];
}
return result;
}
// Helper function to check if address exists in array
function _addressExistsInArray(address[] memory _array, address _addr) private pure returns (bool) {
for (uint256 i = 0; i < _array.length; i++) {
if (_array[i] == _addr) {
return true;
}
}
return false;
}
// Clean up function to remove duplicate authorized users (emergency fix)
function cleanupFileAccess(uint256 _fileId) external fileExists(_fileId) onlyFileOwner(_fileId) {
address[] storage users = files[_fileId].authorizedUsers;
address[] memory uniqueUsers = new address[](users.length);
uint256 uniqueCount = 0;
// Create array of unique users
for (uint256 i = 0; i < users.length; i++) {
bool isDuplicate = false;
for (uint256 j = 0; j < uniqueCount; j++) {
if (uniqueUsers[j] == users[i]) {
isDuplicate = true;
break;
}
}
if (!isDuplicate) {
uniqueUsers[uniqueCount] = users[i];
uniqueCount++;
}
}
// Clear and rebuild the authorized users array
while (users.length > 0) {
users.pop();
}
for (uint256 i = 0; i < uniqueCount; i++) {
users.push(uniqueUsers[i]);
}
}
// Get nickname for a specific emergency responder
function getResponderNickname(address _user, address _responder) external view returns (string memory) {
require(userEmergencyResponders[_user][_responder], "Not an emergency responder");
return userResponderNicknames[_user][_responder];
}
// Update nickname for an existing emergency responder
function updateResponderNickname(address _responder, string memory _newNickname) external {
require(userEmergencyResponders[msg.sender][_responder], "Not an emergency responder");
require(bytes(_newNickname).length > 0, "Nickname cannot be empty");
require(bytes(_newNickname).length <= 50, "Nickname too long (max 50 characters)");
userResponderNicknames[msg.sender][_responder] = _newNickname;
}
// Get list of emergency responders with their nicknames for a user
function getEmergencyRespondersWithNicknames(address _user) external view returns (address[] memory responders, string[] memory nicknames) {
responders = userRespondersList[_user];
nicknames = new string[](responders.length);
for (uint256 i = 0; i < responders.length; i++) {
nicknames[i] = userResponderNicknames[_user][responders[i]];
}
}
}