public string Solve()
{
var pass = GetInput();
const int digits = 8;
var sb = new StringBuilder(digits);
var index = 0;
for (var i = 0; i < digits; i++)
{
string hash;
do
{
index++;
hash = Md5Hasher.GetMd5Hash(pass + index);
if (hash.StartsWith("00000"))
{
break;
}
} while (true);
var letter = hash[5];
sb.Append(letter);
Console.WriteLine($"{letter} - {index}");
}
return(sb.ToString());
}
public void md5hashTest()
{
PasswordHasher target = new Md5Hasher();
string hashedPassword = target.GetHash(@"teste");
string validHash = @"698dc19d489c4e4db73e28a713eab07b";
Assert.True(target.VerifyHash(@"teste", validHash));
}
internal byte[] ComputeHashTopic(string topic)
{
byte[] result;
using (Md5Hasher md5Hasher = new Md5Hasher())
{
byte[] bytes = Encoding.Unicode.GetBytes(topic.ToUpper());
byte[] array = md5Hasher.ComputeHash(bytes);
result = array;
}
return(result);
}
public void Md5HasherHashersToBuckets()
{
int bucketCount = 4;
var dic = new Dictionary <int, string>();
var hasher = new Md5Hasher();
for (int i = 0; i < 1000; i++)
{
dic[hasher.Hash(Guid.NewGuid().ToString(), bucketCount)] = null;
}
Assert.Equal(bucketCount, dic.Count);
}
private CssSpriteManager()
{
var retryableFileOpener = new RetryableFileOpener();
var hasher = new Md5Hasher(retryableFileOpener);
var retryableFileWriter = new RetryableFileWriter(BufferSize, _encoding, retryableFileOpener, hasher);
var cacheManager = new HttpCacheManager();
_pathProvider = new PathProvider();
var cssSpriteMetaDataFileInfo = new FileInfo("cssSprite.metadata");
_cssSpriteMetaData = new SingleFileMetaData(cssSpriteMetaDataFileInfo, retryableFileOpener, retryableFileWriter);
_cssSpriteCreator = new CssSpriteCreator(cacheManager, retryableFileOpener, _pathProvider, retryableFileWriter, _cssSpriteMetaData);
InitManager();
}
private string GenerateName(byte[] bytes, bool randomize = true)
{
if (bytes == null)
{
throw new ArgumentException();
}
var b16Str = Md5Hasher.GenerateBase16Hash(bytes);
var seededName = b16Str;
if (randomize)
{
var seed = DateTime.Now.Second * DateTime.Now.Minute;
seededName += seed.ToString("X");
}
return(seededName);
}
public string Solve()
{
var pass = GetInput();
const int digits = 8;
var list = Enumerable.Range(0, digits).Select(x => (string)null).ToList();
var index = 0;
string hash;
int position;
do
{
index++;
hash = Md5Hasher.GetMd5Hash(pass + index);
if (!hash.StartsWith("00000"))
{
continue;
}
if (!int.TryParse(hash.Substring(5, 1), out position))
{
continue;
}
if (position >= digits)
{
continue;
}
if (list[position] != null)
{
continue;
}
var letter = hash.Substring(6, 1);
list[position] = letter;
Console.WriteLine($"{letter} - {position} - {index}");
if (list.All(x => x != null))
{
break;
}
} while (true);
return(string.Join("", list));
}
private static async Task InsertTestDataAsync(IDbContext context)
{
context.Database.EnsureCreated();
if (context.CredentialTypes.Any())
{
return;
}
var type = CredentialType.Create(Guid.NewGuid(), "Email address", "Email");
var user = User.Create(Guid.NewGuid(), "Administrator");
context.CredentialTypes.Add(type);
await context.SaveChangesAsync();
var cred = Credential.Create(type.Id, "*****@*****.**", Md5Hasher.ComputeHash("admin"));
user.AddCredential(cred);
context.Users.Add(user);
await context.SaveChangesAsync();
}
public override void CalcHashes(Hashes hashFlags, Validations validationFlags)
{
if (IssueModel.Data.HasFatal)
{
return;
}
if ((hashFlags & Hashes.PcmMD5) != 0 && Data.actualMediaMD5 == null)
{
try
{
var hasher = new Md5Hasher();
hasher.Append(Data.fbs, Data.mediaPosition, Data.MediaCount);
Data.actualMediaMD5 = hasher.GetHashAndReset();
}
catch (EndOfStreamException)
{
IssueModel.Add("File truncated near audio.", Severity.Fatal);
}
}
if ((hashFlags & Hashes.PcmCRC32) != 0 && Data.ActualCRC32 == null)
{
try
{
var hasher = new Crc32rHasher();
hasher.Append(Data.fbs, Data.mediaPosition, Data.MediaCount);
var hash = hasher.GetHashAndReset();
Data.ActualCRC32 = BitConverter.ToUInt32(hash, 0);
}
catch (EndOfStreamException)
{
IssueModel.Add("File truncated near audio.", Severity.Fatal);
}
}
base.CalcHashes(hashFlags, validationFlags);
}
private ClaimsIdentity GetIdentity(string username, string password)
{
var hashProvider = new Md5Hasher();
password = hashProvider.GetMd5Hash(password);
var user = db.Users.FirstOrDefault(x => x.Username == username && x.Password == password);
if (user is null)
{
return(null);
}
var claims = new List <Claim>
{
new Claim("name", username),
new Claim("role", "admin")
};
ClaimsIdentity claimsIdentity = new ClaimsIdentity(claims, "token",
ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType);
return(claimsIdentity);
}
public override void CalcHashes(Hashes hashFlags, Validations validationFlags)
{
if (Data.Issues.HasFatal)
{
return;
}
if ((hashFlags & Hashes.Intrinsic) != 0 && Data.ActualAudioHeaderCRC8 == null)
{
var hasher1 = new Crc8Hasher();
hasher1.Append(Data.aHdr);
byte[] hash1 = hasher1.GetHashAndReset();
Data.ActualAudioHeaderCRC8 = hash1[0];
try
{
var hasher2 = new Crc16nHasher();
hasher2.Append(Data.fbs, Data.mediaPosition, Data.FileSize - Data.mediaPosition - 2);
byte[] hash2 = hasher2.GetHashAndReset();
Data.ActualAudioBlockCRC16 = BitConverter.ToUInt16(hash2, 0);
}
catch (EndOfStreamException ex)
{
IssueModel.Add("Read failed while checking audio CRC: " + ex.Message, Severity.Fatal);
return;
}
if (!Data.IsBadDataCRC && !Data.IsBadHeaderCRC)
{
Data.ChIssue = Data.CdIssue = IssueModel.Add("CRC checks successful on audio header and data.", Severity.Noise, IssueTags.Success);
}
else
{
if (Data.IsBadHeaderCRC)
{
Data.ChIssue = IssueModel.Add("CRC-8 check failed on audio header.", Severity.Error, IssueTags.Failure);
}
else
{
Data.ChIssue = IssueModel.Add("CRC-8 check successful on audio header.", Severity.Noise, IssueTags.Success);
}
if (Data.IsBadDataCRC)
{
Data.CdIssue = IssueModel.Add("CRC-16 check failed on audio data.", Severity.Error, IssueTags.Failure);
}
else
{
Data.CdIssue = IssueModel.Add("CRC-16 check successful on audio data.", Severity.Noise, IssueTags.Success);
}
}
}
if ((hashFlags & Hashes.PcmMD5) != 0 && Data.actualAudioDataMD5 == null)
{
Process px = null;
try
{ px = StartFlac(Data.Path); }
catch (Exception ex)
{ IssueModel.Add("flac executable failed with '" + ex.Message.Trim(null) + "'."); }
if (px != null)
{
using (var br = new BinaryReader(px.StandardOutput.BaseStream))
{
try
{
var hasher = new Md5Hasher();
hasher.Append(br);
var hash = hasher.GetHashAndReset();
Data.actualAudioDataMD5 = hash;
}
catch (EndOfStreamException ex)
{ IssueModel.Add("Read failed while verifying audio MD5: " + ex.Message, Severity.Fatal); }
if (Data.IsBadDataMD5)
{
Data.CmIssue = IssueModel.Add("MD5 check failed on audio data.", Severity.Error, IssueTags.Failure);
}
else
{
Data.CmIssue = IssueModel.Add("MD5 check successful on audio data.", Severity.Noise, IssueTags.Success);
}
}
}
}
if ((hashFlags & (Hashes.PcmCRC32 | Hashes._FlacMatch)) != 0 && Data.ActualPcmCRC32 == null)
{
Process px = null;
try
{ px = StartFlac(Data.Path); }
catch (Exception ex)
{ IssueModel.Add("flac executable failed with '" + ex.Message.Trim(null) + "'."); }
if (px != null)
{
using (var br = new BinaryReader(px.StandardOutput.BaseStream))
{
var hasher = new Crc32rHasher();
hasher.Append(br);
byte[] hash = hasher.GetHashAndReset();
Data.ActualPcmCRC32 = BitConverter.ToUInt32(hash, 0);
}
}
}
if ((hashFlags & (Hashes._FlacTags)) != 0)
{
TagCheckNumber("TRACKNUMBER");
TagCheckNumber("TRACKTOTAL", optional: true);
TagCheckNumber("DISCNUMBER", true);
TagCheckNumber("DISCTOTAL", true);
TagCheckDate("DATE");
TagCheckDate("RELEASE DATE", optional: true);
TagCheckDate("ORIGINAL RELEASE DATE", true);
TagCheckText("TITLE");
TagCheckText("ARTIST");
TagCheckText("ALBUM");
TagCheckText("ALBUMARTIST", optional: true);
TagCheckText("ALBUMARTISTSORTORDER", true);
TagCheckText("ORGANIZATION", true);
TagCheckText("BARCODE", true);
TagCheckText("CATALOGNUMBER", true);
}
base.CalcHashes(hashFlags, validationFlags);
}
public static IMapper Initialize()
{
var mapperConfiguration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <RegisterUserDto, User>()
.ForMember(dest => dest.UserName, opts => opts.MapFrom(src => src.Email));
cfg.CreateMap <ExternalUserDto, User>()
.ForMember(dest => dest.UserName, opts => opts.MapFrom(src => src.Email))
.ForMember(dest => dest.EmailConfirmed, opts => opts.MapFrom(src => true));
cfg.CreateMap <User, UserProfileDto>()
.ForMember(
profile => profile.HashMail,
options => options.MapFrom(user => Md5Hasher.HashString(user.Email)));
cfg.CreateMap <ExternalUser, UserProfileDto>()
.ForMember(
profile => profile.HashMail,
options => options.MapFrom(user => Guid.NewGuid().ToString("d")));
cfg.CreateMap <User, SecureUserProfileDto>()
.IncludeBase <User, UserProfileDto>();
cfg.CreateMap <User, MemberDto>()
.ForMember(
profile => profile.HashMail,
options => options.MapFrom(user => Md5Hasher.HashString(user.Email)));
cfg.CreateMap <AddBoardDto, Board>();
cfg.CreateMap <Board, BoardMiniatureDto>()
.ForMember(dest => dest.MembersCount,
opt => opt.MapFrom(src => src.Members.Count(x => !x.IsDeleted)));
cfg.CreateMap <Board, BoardDto>();
cfg.CreateMap <EditBoardDto, Board>();
cfg.CreateMap <Board, UserBoard>()
.ForMember(dest => dest.Board,
opts => opts.MapFrom(src => src))
.ForMember(dest => dest.UserId,
opts => opts.MapFrom(src => src.OwnerId))
.ForMember(dest => dest.BoardId,
opts => opts.MapFrom(src => src.Id));
cfg.CreateMap <UserBoard, UserBoardDto>();
cfg.CreateMap <AddListDto, List>();
cfg.CreateMap <EditListDto, List>();
cfg.CreateMap <List, ListDto>();
cfg.CreateMap <AddCardDto, Card>();
cfg.CreateMap <EditCardNameDto, Card>();
cfg.CreateMap <EditCardDescriptionDto, Card>();
cfg.CreateMap <Card, CardDto>();
cfg.CreateMap <Card, CardDetailsDto>()
.ForMember(dest => dest.ListName,
opts => opts.MapFrom(src => src.List.Name));
cfg.CreateMap <CommentCardDto, Comment>();
cfg.CreateMap <Comment, CommentDto>();
});
return(mapperConfiguration.CreateMapper());
}
public static byte[] MD5(byte[] bytes) => Md5Hasher.Hash(bytes);
public override void CalcHashes(Hashes hashFlags, Validations validationFlags)
{
if (Data.Issues.HasFatal)
{
return;
}
if ((hashFlags & Hashes.Intrinsic) != 0)
{
if (Data.ActualAudioHeaderCRC8 == null)
{
var hasher = new Crc8Hasher();
hasher.Append(Data.aHdr);
var hash = hasher.GetHashAndReset();
Data.ActualAudioHeaderCRC8 = hash[0];
if (Data.IsBadHeader)
{
IssueModel.Add("CRC-8 check failed on audio header.");
}
}
if (Data.ActualAudioBlockCRC16 == null)
{
try
{
var hasher = new Crc16nHasher();
hasher.Append(Data.fbs, Data.mediaPosition, Data.FileSize - Data.mediaPosition - 2);
var hash = hasher.GetHashAndReset();
Data.ActualAudioBlockCRC16 = BitConverter.ToUInt16(hash, 0);
}
catch (EndOfStreamException ex)
{
IssueModel.Add("Read failed while verifying audio CRC: " + ex.Message, Severity.Fatal);
return;
}
}
if (Data.IsBadDataCRC16)
{
IssueModel.Add("CRC-16 check failed on audio data.");
}
else
if (Data.IsBadHeader)
{
IssueModel.Add("CRC-16 check successful.", Severity.Advisory);
}
else
{
IssueModel.Add("CRC-8, CRC-16 checks successful.", Severity.Noise);
}
}
#if !NETFX_CORE
if ((hashFlags & Hashes.PcmMD5) != 0 && Data.actualAudioDataMD5 == null)
{
Process px = null;
try
{ px = StartFlac(Data.Path); }
catch (Exception ex)
{ IssueModel.Add("flac executable failed with '" + ex.Message.Trim(null) + "'."); }
if (px != null)
{
using (var br = new BinaryReader(px.StandardOutput.BaseStream))
{
try
{
var hasher = new Md5Hasher();
hasher.Append(br);
var hash = hasher.GetHashAndReset();
Data.actualAudioDataMD5 = hash;
}
catch (EndOfStreamException ex)
{ IssueModel.Add("Read failed while verifying audio MD5: " + ex.Message, Severity.Fatal); }
if (Data.IsBadDataMD5)
{
IssueModel.Add("MD5 check failed on audio data.");
}
else
{
IssueModel.Add("MD5 check successful.", Severity.Noise);
}
}
}
}
if ((hashFlags & Hashes.PcmCRC32) != 0 && Data.ActualPcmCRC32 == null)
{
Process px = null;
try
{ px = StartFlac(Data.Path); }
catch (Exception ex)
{ IssueModel.Add("flac executable failed with '" + ex.Message.Trim(null) + "'."); }
if (px != null)
{
using (var br = new BinaryReader(px.StandardOutput.BaseStream))
{
var hasher = new Crc32rHasher();
hasher.Append(br);
var hash = hasher.GetHashAndReset();
Data.ActualPcmCRC32 = BitConverter.ToUInt32(hash, 0);
}
}
}
#endif
base.CalcHashes(hashFlags, validationFlags);
}
public virtual void CalcHashes(Hashes hashFlags, Validations validationFlags)
{
if (IssueModel.Data.HasFatal)
{
return;
}
bool hitCache = Data.fBuf != null && Data.FileSize < Int32.MaxValue;
if ((hashFlags & Hashes.FileMD5) != 0 && Data.fileMD5 == null)
{
var hasher = new Md5Hasher();
if (hitCache)
{
hasher.Append(Data.fBuf, 0, Data.fBuf.Length);
}
else
{
hasher.Append(Data.fbs);
}
Data.fileMD5 = hasher.GetHashAndReset();
}
if ((hashFlags & Hashes.FileSHA1) != 0 && Data.fileSHA1 == null)
{
var hasher = new Sha1Hasher();
if (hitCache)
{
hasher.Append(Data.fBuf, 0, Data.fBuf.Length);
}
else
{
hasher.Append(Data.fbs);
}
Data.fileSHA1 = hasher.GetHashAndReset();
}
if ((hashFlags & Hashes.FileSHA256) != 0 && Data.fileSHA256 == null)
{
var hasher = new Sha256Hasher();
if (hitCache)
{
hasher.Append(Data.fBuf, 0, Data.fBuf.Length);
}
else
{
hasher.Append(Data.fbs);
}
Data.fileSHA256 = hasher.GetHashAndReset();
}
if ((hashFlags & Hashes.MediaSHA1) != 0 && Data.mediaSHA1 == null)
{
if (Data.MediaCount == Data.FileSize && Data.fileSHA1 != null)
{
System.Diagnostics.Debug.Assert(Data.mediaPosition == 0);
Data.mediaSHA1 = Data.fileSHA1;
}
else
{
var hasher = new Sha1Hasher();
if (hitCache)
{
hasher.Append(Data.fBuf, (int)Data.mediaPosition, (int)Data.MediaCount);
}
else
{
hasher.Append(Data.fbs, Data.mediaPosition, Data.MediaCount);
}
Data.mediaSHA1 = hasher.GetHashAndReset();
}
}
if ((hashFlags & Hashes.MetaSHA1) != 0 && Data.metaSHA1 == null)
{
var hasher = new Sha1Hasher();
var suffixPos = Data.mediaPosition + Data.MediaCount;
if (hitCache)
{
hasher.Append(Data.fBuf, 0, (int)Data.mediaPosition, (int)suffixPos, (int)(Data.FileSize - suffixPos));
}
else
{
hasher.Append(Data.fbs, 0, Data.mediaPosition, suffixPos, Data.FileSize - suffixPos);
}
Data.metaSHA1 = hasher.GetHashAndReset();
}
}
static int Main(string[] args)
{
var showHelp = false;
var configPath = string.Empty;
var crusherSectionName = "Crusher";
var cssSpriteSectionName = "CssSprite";
var applicationPath = "/";
var options = new OptionSet()
{
{
"c=|configPath=",
"the configuration path to the web.config or app.config file. E.g. ../../../Talifun.Web.Examples/Crusher.Demo/web.config",
c => configPath = c
},
{
"cs=|crusherSectionName=",
"the section name of the configuration element for the Talifun.Crusher configuration. Defaults to 'Crusher' if not specified.",
cs => crusherSectionName = cs
},
{
"css=|cssSpriteSectionName=",
"the section name of the configuration element for the Talifun.CssSprite configuration. Defaults to 'CssSprite' if not specified.",
css => cssSpriteSectionName = css
},
{
"a=|applicationPath=",
"the application path to be relative from. Defaults to '/' if not specified.",
a => applicationPath = a
},
{
"?|h|help",
"display help screen",
h => showHelp = h != null
}
};
try
{
options.Parse(args);
}
catch (OptionException e)
{
Console.WriteLine(HeaderMessage);
Console.WriteLine(e.Message);
Console.WriteLine(UsageMessage);
Console.WriteLine(HelpMessage);
return(DisplayHelpScreenExitCode);
}
if (showHelp)
{
DisplayHelp(options);
return(DisplayHelpScreenExitCode);
}
if (string.IsNullOrEmpty(configPath))
{
Console.WriteLine(HeaderMessage);
Console.WriteLine(UsageMessage);
Console.WriteLine(HelpMessage);
return(DisplayHelpScreenExitCode);
}
var crusherConfiguration = GetCrusherSection(configPath, crusherSectionName);
if (crusherConfiguration == null)
{
Console.WriteLine(HeaderMessage);
Console.WriteLine("\"{0}\" section name not found in {1} ", crusherSectionName, configPath);
Console.WriteLine(HelpMessage);
return(DisplayHelpScreenExitCode);
}
try
{
Console.WriteLine();
Console.WriteLine("Settings used:");
Console.WriteLine("configPath = " + configPath);
Console.WriteLine("crusherSectionName = " + crusherSectionName);
Console.WriteLine("applicationPath = " + applicationPath);
var configUri = new Uri(configPath, UriKind.RelativeOrAbsolute);
if (!configUri.IsAbsoluteUri)
{
configUri = new Uri(Path.Combine(Environment.CurrentDirectory, configUri.ToString()));
}
var physicalApplicationPath = new FileInfo(configUri.LocalPath).DirectoryName;
var retryableFileOpener = new RetryableFileOpener();
var hasher = new Md5Hasher(retryableFileOpener);
var retryableFileWriter = new RetryableFileWriter(BufferSize, Encoding, retryableFileOpener, hasher);
var pathProvider = new PathProvider(applicationPath, physicalApplicationPath);
var cacheManager = new HttpCacheManager();
var fileMetaData = new MultiFileMetaData(retryableFileOpener, retryableFileWriter);
var jsOutput = string.Empty;
var cssOutput = string.Empty;
var cssSpriteOutput = string.Empty;
//We want to be able to use output from css sprites in crushed content
var countdownEvents = new CountdownEvent(3);
var cssSpriteExceptions = new List <CssSpriteException>();
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
if (crusherConfiguration != null)
{
var cssSpriteGroups = crusherConfiguration.CssSpriteGroups;
var cssSpriteCreator = new CssSpriteCreator(cacheManager, retryableFileOpener, pathProvider, retryableFileWriter, fileMetaData);
var cssSpriteGroupsProcessor = new CssSpriteGroupsProcessor();
cssSpriteOutput = cssSpriteGroupsProcessor.ProcessGroups(pathProvider, cssSpriteCreator, cssSpriteGroups).ToString();
}
}
catch (Exception exception)
{
cssSpriteExceptions.Add(new CssSpriteException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
var jsExceptions = new List <JsException>();
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
if (crusherConfiguration != null)
{
var jsCrusher = new JsCrusher(cacheManager, pathProvider, retryableFileOpener, retryableFileWriter, fileMetaData);
var jsGroups = crusherConfiguration.JsGroups;
var jsGroupsProcessor = new JsGroupsProcessor();
jsOutput = jsGroupsProcessor.ProcessGroups(pathProvider, jsCrusher, jsGroups).ToString();
}
}
catch (Exception exception)
{
jsExceptions.Add(new JsException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
var cssExceptions = new List <CssException>();
ThreadPool.QueueUserWorkItem(data =>
{
var manualResetEvent = (CountdownEvent)data;
try
{
if (crusherConfiguration != null)
{
var hashQueryStringKeyName = crusherConfiguration.QuerystringKeyName;
var cssAssetsFileHasher = new CssAssetsFileHasher(hashQueryStringKeyName, hasher, pathProvider);
var cssPathRewriter = new CssPathRewriter(cssAssetsFileHasher, pathProvider);
var cssCrusher = new CssCrusher(cacheManager, pathProvider, retryableFileOpener, retryableFileWriter, cssPathRewriter, fileMetaData, crusherConfiguration.WatchAssets);
var cssGroups = crusherConfiguration.CssGroups;
var cssGroupsCrusher = new CssGroupsProcessor();
cssOutput = cssGroupsCrusher.ProcessGroups(pathProvider, cssCrusher, cssGroups).ToString();
}
}
catch (Exception exception)
{
cssExceptions.Add(new CssException(exception));
}
manualResetEvent.Signal();
}, countdownEvents);
countdownEvents.Wait();
if (string.IsNullOrEmpty(cssSpriteOutput) && !cssSpriteExceptions.Any())
{
Console.WriteLine();
Console.WriteLine("Skipping css sprite creation. \"{0}\" section name not found in \"{1}\"", cssSpriteSectionName, configPath);
}
else
{
Console.WriteLine();
Console.WriteLine(cssSpriteOutput);
if (cssSpriteExceptions.Any())
{
Console.WriteLine("Css sprite errors:");
Console.WriteLine(new AggregateException(cssSpriteExceptions.Cast <Exception>()));
}
}
if (string.IsNullOrEmpty(jsOutput) && string.IsNullOrEmpty(cssOutput) && !jsExceptions.Any() && !cssExceptions.Any())
{
Console.WriteLine();
Console.WriteLine("Skipping css/js crushed content creation. \"{0}\" section name not found in \"{1}\"", crusherSectionName, configPath);
}
else
{
Console.WriteLine();
Console.WriteLine(cssOutput);
if (cssExceptions.Any())
{
Console.WriteLine("Css errors:");
Console.WriteLine(new AggregateException(cssExceptions.Cast <Exception>()));
}
Console.WriteLine();
Console.WriteLine(jsOutput);
if (jsExceptions.Any())
{
Console.WriteLine("Js errors:");
Console.WriteLine(new AggregateException(jsExceptions.Cast <Exception>()));
}
}
}
catch (Exception exception)
{
Console.Write(exception);
return(ErrorExitCode);
}
return(SuccessExitCode);
}
public bool IsPasswordValid(string password)
{
return(Enumerable.SequenceEqual(Password, Md5Hasher.GenerateBytes(password)));
}
public User SetPassword(string password)
{
Password = Md5Hasher.GenerateBytes(password);
return(this);
}
public User Validate(string loginTypeCode, string identifier, string secret)
{
var credentialType = _context.CredentialTypes.FirstOrDefault(ct => string.Equals(ct.Code, loginTypeCode, StringComparison.OrdinalIgnoreCase));
if (credentialType == null)
{
return(null);
}
var credential = _context.Credentials.FirstOrDefault(
c => c.CredentialTypeId == credentialType.Id && string.Equals(c.Identifier, identifier, StringComparison.OrdinalIgnoreCase) && c.Secret == Md5Hasher.ComputeHash(secret)
);
if (credential == null)
{
return(null);
}
return(_context.Users.Find(credential.UserId));
}
