Task 821: .WSC File Format
Task 821: .WSC File Format
1. List of Properties Intrinsic to the .WSC File Format
The .WSC file format, used for Windows Script Components, is an XML-based structure that defines reusable COM components through scripting. The properties intrinsic to this format refer to the key XML elements and their attributes that define the component's metadata, interface, and supporting features. These are not file system attributes (e.g., size or timestamp) but rather the structural components embedded within the file itself. Based on detailed specifications from reliable sources, the comprehensive list of properties includes:
- Component ID: A unique identifier for the component (attribute of
<component>element; optional, defaults to a generated value). - Package Grouping: Indicates if multiple components are grouped (presence of
<package>element; optional for single-component files). - Registration Details:
- ProgID: Programmatic identifier for instantiating the component (attribute of
<registration>). - ClassID: Globally unique identifier (GUID) for the COM class (attribute of
<registration>). - Description: Textual description of the component (attribute of
<registration>). - Version: Version number of the component (attribute of
<registration>). - Remotable: Boolean flag indicating DCOM support (attribute of
<registration>; optional). - Public Interface:
- Properties: List of exposed properties, each with:
- Name (attribute of
<property>). - Internal Name (optional attribute of
<property>). - Get Function (presence of
<get>child or attribute; optional internal name). - Put Function (presence of
<put>child or attribute; optional internal name). - Methods: List of exposed methods, each with:
- Name (attribute of
<method>). - Internal Name (optional attribute of
<method>). - Dispatch ID (optional attribute of
<method>). - Parameters: List of method parameters, each with name and type (child
<parameter>elements). - Events: List of firable events, each with:
- Name (attribute of
<event>). - Dispatch ID (attribute of
<event>; optional). - Implements Handlers: Additional COM interfaces (e.g., ASP), each with:
- Type (attribute of
<implements>). - ID (optional attribute of
<implements>). - Default Flag (optional boolean attribute of
<implements>). - Objects: Instantiated COM objects, each with:
- ID (attribute of
<object>). - ClassID or ProgID (attributes of
<object>). - Resources: Static data resources, each with:
- ID (attribute of
<resource>). - Content (text content of
<resource>). - References: Imported type libraries, each with:
- Object or GUID (attributes of
<reference>). - Version (optional attribute of
<reference>). - Comments: Descriptive text notes (text content of
<comment>elements; optional). - Script Definitions:
- Language: Scripting language (e.g., VBScript, JScript; attribute of
<script>). - Code Content: Embedded script code (text within
<script>, often in CDATA; this is the implementation but treated as a property for dumping).
These properties form the core structure, enabling the file to function as a registrable COM object.
2. Two Direct Download Links for .WSC Files
- https://raw.githubusercontent.com/duosecurity/duo_classicasp/master/duo.wsc
- https://raw.githubusercontent.com/zendesk/classic_asp_jwt/master/external/sha256.wsc
3. Ghost Blog Embedded HTML/JavaScript for Drag-and-Drop .WSC File Dump
The following is a self-contained HTML snippet with embedded JavaScript that can be embedded in a Ghost blog (or any HTML-supporting platform). It allows users to drag and drop a .WSC file, parses the XML, extracts the properties listed in section 1, and displays them on the screen in a structured format.
Drag and drop a .WSC file here
4. Python Class for .WSC File Handling
The following Python class uses the xml.etree.ElementTree module to open, decode (parse), read, write, and print the properties of a .WSC file to the console.
import xml.etree.ElementTree as ET
import os
class WSCFileHandler:
def __init__(self, filepath):
self.filepath = filepath
self.tree = None
self.root = None
self.properties = {}
def read(self):
"""Parse and decode the .WSC file."""
if not os.path.exists(self.filepath):
raise FileNotFoundError(f"File not found: {self.filepath}")
self.tree = ET.parse(self.filepath)
self.root = self.tree.getroot()
self._extract_properties()
def _extract_properties(self):
"""Extract properties from the XML structure."""
self.properties = {
'component_id': self.root.get('id', 'Default') if self.root.tag == 'component' else '',
'package_present': any(elem.tag == 'package' for elem in self.root),
'registration': {},
'public_interface': {'properties': [], 'methods': [], 'events': []},
'implements_handlers': [],
'objects': [],
'resources': [],
'references': [],
'comments': [],
'scripts': []
}
reg = self.root.find('registration')
if reg is not None:
self.properties['registration'] = {
'progid': reg.get('progid'),
'classid': reg.get('classid'),
'description': reg.get('description'),
'version': reg.get('version'),
'remotable': reg.get('remotable')
}
public = self.root.find('public')
if public is not None:
for prop in public.findall('property'):
self.properties['public_interface']['properties'].append({
'name': prop.get('name'),
'internalname': prop.get('internalname'),
'get': prop.get('get') or prop.find('get').get('internalname') if prop.find('get') else None,
'put': prop.get('put') or prop.find('put').get('internalname') if prop.find('put') else None
})
for method in public.findall('method'):
params = [{'name': p.get('name'), 'type': p.get('type')} for p in method.findall('parameter')]
self.properties['public_interface']['methods'].append({
'name': method.get('name'),
'internalname': method.get('internalname'),
'dispid': method.get('dispid'),
'parameters': params
})
for event in public.findall('event'):
self.properties['public_interface']['events'].append({
'name': event.get('name'),
'dispid': event.get('dispid')
})
for impl in self.root.findall('implements'):
self.properties['implements_handlers'].append({
'type': impl.get('type'),
'id': impl.get('id'),
'default': impl.get('default')
})
for obj in self.root.findall('object'):
self.properties['objects'].append({
'id': obj.get('id'),
'classid': obj.get('classid'),
'progid': obj.get('progid')
})
for res in self.root.findall('resource'):
self.properties['resources'].append({
'id': res.get('id'),
'content': res.text.strip() if res.text else ''
})
for ref in self.root.findall('reference'):
self.properties['references'].append({
'object': ref.get('object'),
'guid': ref.get('guid'),
'version': ref.get('version')
})
for comment in self.root.findall('comment'):
self.properties['comments'].append(comment.text.strip() if comment.text else '')
for script in self.root.findall('script'):
self.properties['scripts'].append({
'language': script.get('language'),
'code': script.text.strip() if script.text else ''
})
def print_properties(self):
"""Print extracted properties to console."""
import json
print(json.dumps(self.properties, indent=4))
def write(self, new_filepath=None):
"""Write the parsed XML back to file (or modify in place)."""
if new_filepath is None:
new_filepath = self.filepath
self.tree.write(new_filepath, encoding='utf-8', xml_declaration=True)
# Example usage:
# handler = WSCFileHandler('example.wsc')
# handler.read()
# handler.print_properties()
# handler.write('modified.wsc')
5. Java Class for .WSC File Handling
The following Java class uses javax.xml.parsers to open, decode (parse), read, write, and print the properties of a .WSC file to the console.
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.ArrayList;
import java.util.List;
public class WSCFileHandler {
private String filepath;
private Document document;
private Map<String, Object> properties;
public WSCFileHandler(String filepath) {
this.filepath = filepath;
this.properties = new HashMap<>();
}
public void read() throws Exception {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
this.document = builder.parse(new File(filepath));
extractProperties();
}
private void extractProperties() {
properties.clear();
Element root = document.getDocumentElement();
properties.put("component_id", root.getAttribute("id").isEmpty() ? "Default" : root.getAttribute("id"));
properties.put("package_present", root.getElementsByTagName("package").getLength() > 0);
Map<String, String> registration = new HashMap<>();
Element reg = (Element) root.getElementsByTagName("registration").item(0);
if (reg != null) {
registration.put("progid", reg.getAttribute("progid"));
registration.put("classid", reg.getAttribute("classid"));
registration.put("description", reg.getAttribute("description"));
registration.put("version", reg.getAttribute("version"));
registration.put("remotable", reg.getAttribute("remotable"));
}
properties.put("registration", registration);
Map<String, List<Map<String, Object>>> publicInterface = new HashMap<>();
publicInterface.put("properties", new ArrayList<>());
publicInterface.put("methods", new ArrayList<>());
publicInterface.put("events", new ArrayList<>());
Element publicElem = (Element) root.getElementsByTagName("public").item(0);
if (publicElem != null) {
NodeList props = publicElem.getElementsByTagName("property");
for (int i = 0; i < props.getLength(); i++) {
Element prop = (Element) props.item(i);
Map<String, Object> propMap = new HashMap<>();
propMap.put("name", prop.getAttribute("name"));
propMap.put("internalname", prop.getAttribute("internalname"));
propMap.put("get", prop.getAttribute("get"));
if (propMap.get("get").equals("")) {
Element getElem = (Element) prop.getElementsByTagName("get").item(0);
if (getElem != null) propMap.put("get", getElem.getAttribute("internalname"));
}
propMap.put("put", prop.getAttribute("put"));
if (propMap.get("put").equals("")) {
Element putElem = (Element) prop.getElementsByTagName("put").item(0);
if (putElem != null) propMap.put("put", putElem.getAttribute("internalname"));
}
((List<Map<String, Object>>) publicInterface.get("properties")).add(propMap);
}
NodeList methods = publicElem.getElementsByTagName("method");
for (int i = 0; i < methods.getLength(); i++) {
Element method = (Element) methods.item(i);
Map<String, Object> methodMap = new HashMap<>();
methodMap.put("name", method.getAttribute("name"));
methodMap.put("internalname", method.getAttribute("internalname"));
methodMap.put("dispid", method.getAttribute("dispid"));
List<Map<String, String>> params = new ArrayList<>();
NodeList paramNodes = method.getElementsByTagName("parameter");
for (int j = 0; j < paramNodes.getLength(); j++) {
Element param = (Element) paramNodes.item(j);
Map<String, String> paramMap = new HashMap<>();
paramMap.put("name", param.getAttribute("name"));
paramMap.put("type", param.getAttribute("type"));
params.add(paramMap);
}
methodMap.put("parameters", params);
((List<Map<String, Object>>) publicInterface.get("methods")).add(methodMap);
}
NodeList events = publicElem.getElementsByTagName("event");
for (int i = 0; i < events.getLength(); i++) {
Element event = (Element) events.item(i);
Map<String, String> eventMap = new HashMap<>();
eventMap.put("name", event.getAttribute("name"));
eventMap.put("dispid", event.getAttribute("dispid"));
((List<Map<String, Object>>) publicInterface.get("events")).add(eventMap);
}
}
properties.put("public_interface", publicInterface);
List<Map<String, String>> implementsHandlers = new ArrayList<>();
NodeList impls = root.getElementsByTagName("implements");
for (int i = 0; i < impls.getLength(); i++) {
Element impl = (Element) impls.item(i);
Map<String, String> implMap = new HashMap<>();
implMap.put("type", impl.getAttribute("type"));
implMap.put("id", impl.getAttribute("id"));
implMap.put("default", impl.getAttribute("default"));
implementsHandlers.add(implMap);
}
properties.put("implements_handlers", implementsHandlers);
List<Map<String, String>> objects = new ArrayList<>();
NodeList objs = root.getElementsByTagName("object");
for (int i = 0; i < objs.getLength(); i++) {
Element obj = (Element) objs.item(i);
Map<String, String> objMap = new HashMap<>();
objMap.put("id", obj.getAttribute("id"));
objMap.put("classid", obj.getAttribute("classid"));
objMap.put("progid", obj.getAttribute("progid"));
objects.add(objMap);
}
properties.put("objects", objects);
List<Map<String, String>> resources = new ArrayList<>();
NodeList reses = root.getElementsByTagName("resource");
for (int i = 0; i < reses.getLength(); i++) {
Element res = (Element) reses.item(i);
Map<String, String> resMap = new HashMap<>();
resMap.put("id", res.getAttribute("id"));
resMap.put("content", res.getTextContent().trim());
resources.add(resMap);
}
properties.put("resources", resources);
List<Map<String, String>> references = new ArrayList<>();
NodeList refs = root.getElementsByTagName("reference");
for (int i = 0; i < refs.getLength(); i++) {
Element ref = (Element) refs.item(i);
Map<String, String> refMap = new HashMap<>();
refMap.put("object", ref.getAttribute("object"));
refMap.put("guid", ref.getAttribute("guid"));
refMap.put("version", ref.getAttribute("version"));
references.add(refMap);
}
properties.put("references", references);
List<String> comments = new ArrayList<>();
NodeList coms = root.getElementsByTagName("comment");
for (int i = 0; i < coms.getLength(); i++) {
comments.add(coms.item(i).getTextContent().trim());
}
properties.put("comments", comments);
List<Map<String, String>> scripts = new ArrayList<>();
NodeList scrs = root.getElementsByTagName("script");
for (int i = 0; i < scrs.getLength(); i++) {
Element scr = (Element) scrs.item(i);
Map<String, String> scrMap = new HashMap<>();
scrMap.put("language", scr.getAttribute("language"));
scrMap.put("code", scr.getTextContent().trim());
scripts.add(scrMap);
}
properties.put("scripts", scripts);
}
public void printProperties() {
System.out.println(propertiesToJson(properties));
}
private String propertiesToJson(Map<String, Object> map) {
// Simple JSON serialization for console output (production use Gson or similar)
StringBuilder sb = new StringBuilder("{\n");
for (Map.Entry<String, Object> entry : map.entrySet()) {
sb.append(" \"").append(entry.getKey()).append("\": ");
if (entry.getValue() instanceof Map || entry.getValue() instanceof List) {
sb.append(entry.getValue().toString()); // Simplified; use proper recursion for deep JSON
} else {
sb.append("\"").append(entry.getValue()).append("\"");
}
sb.append(",\n");
}
sb.append("}");
return sb.toString();
}
public void write(String newFilepath) throws Exception {
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource source = new DOMSource(document);
StreamResult result = new StreamResult(new File(newFilepath == null ? filepath : newFilepath));
transformer.transform(source, result);
}
// Example usage:
// public static void main(String[] args) throws Exception {
// WSCFileHandler handler = new WSCFileHandler("example.wsc");
// handler.read();
// handler.printProperties();
// handler.write("modified.wsc");
// }
}
6. JavaScript Class for .WSC File Handling
The following JavaScript class (Node.js compatible) uses the fs and xml2js modules (assume xml2js is installed) to open, decode (parse), read, write, and print the properties of a .WSC file to the console. For browser use, adapt file reading.
const fs = require('fs');
const xml2js = require('xml2js');
class WSCFileHandler {
constructor(filepath) {
this.filepath = filepath;
this.xmlContent = null;
this.properties = {};
}
async read() {
this.xmlContent = fs.readFileSync(this.filepath, 'utf-8');
const parser = new xml2js.Parser({ explicitArray: false });
const result = await parser.parseStringPromise(this.xmlContent);
this._extractProperties(result);
}
_extractProperties(xmlObj) {
this.properties = {
component_id: xmlObj.component?.$?.id || 'Default',
package_present: !!xmlObj.package,
registration: xmlObj.component?.registration?.$ || {},
public_interface: {
properties: Array.isArray(xmlObj.component?.public?.property) ? xmlObj.component.public.property : [xmlObj.component?.public?.property || {}],
methods: Array.isArray(xmlObj.component?.public?.method) ? xmlObj.component.public.method : [xmlObj.component?.public?.method || {}],
events: Array.isArray(xmlObj.component?.public?.event) ? xmlObj.component.public.event : [xmlObj.component?.public?.event || {}]
},
implements_handlers: Array.isArray(xmlObj.component?.implements) ? xmlObj.component.implements : [xmlObj.component?.implements || {}],
objects: Array.isArray(xmlObj.component?.object) ? xmlObj.component.object : [xmlObj.component?.object || {}],
resources: Array.isArray(xmlObj.component?.resource) ? xmlObj.component.resource : [xmlObj.component?.resource || {}],
references: Array.isArray(xmlObj.component?.reference) ? xmlObj.component.reference : [xmlObj.component?.reference || {}],
comments: Array.isArray(xmlObj.component?.comment) ? xmlObj.component.comment : [xmlObj.component?.comment || ''],
scripts: Array.isArray(xmlObj.component?.script) ? xmlObj.component.script : [xmlObj.component?.script || {}]
};
// Normalize properties for get/put if child elements
this.properties.public_interface.properties = this.properties.public_interface.properties.map(prop => {
if (prop.get || prop.put) {
prop.get = prop.get?.$?.internalName || prop.get;
prop.put = prop.put?.$?.internalName || prop.put;
}
return prop.$ || prop;
});
// Normalize methods for parameters
this.properties.public_interface.methods = this.properties.public_interface.methods.map(method => {
method.parameters = Array.isArray(method.parameter) ? method.parameter : [method.parameter || {}];
return method.$ || method;
});
}
printProperties() {
console.log(JSON.stringify(this.properties, null, 2));
}
write(newFilepath = this.filepath) {
fs.writeFileSync(newFilepath, this.xmlContent, 'utf-8');
}
}
// Example usage:
// const handler = new WSCFileHandler('example.wsc');
// await handler.read();
// handler.printProperties();
// handler.write('modified.wsc');
7. C++ Class for .WSC File Handling
The following C++ class uses the TinyXML2 library (assume included) to open, decode (parse), read, write, and print the properties of a .WSC file to the console.
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include "tinyxml2.h" // Assume TinyXML2 is linked
using namespace tinyxml2;
class WSCFileHandler {
private:
std::string filepath;
XMLDocument doc;
std::map<std::string, std::string> registration;
std::vector<std::map<std::string, std::string>> properties_list;
std::vector<std::map<std::string, std::string>> methods;
std::vector<std::map<std::string, std::string>> events;
std::vector<std::map<std::string, std::string>> implements_handlers;
std::vector<std::map<std::string, std::string>> objects;
std::vector<std::map<std::string, std::string>> resources;
std::vector<std::map<std::string, std::string>> references;
std::vector<std::string> comments;
std::vector<std::map<std::string, std::string>> scripts;
std::string component_id;
bool package_present;
public:
WSCFileHandler(const std::string& filepath) : filepath(filepath), package_present(false) {}
void read() {
if (doc.LoadFile(filepath.c_str()) != XML_SUCCESS) {
throw std::runtime_error("Failed to load file");
}
extractProperties();
}
void extractProperties() {
XMLElement* root = doc.RootElement();
component_id = root->Attribute("id") ? root->Attribute("id") : "Default";
package_present = root->FirstChildElement("package") != nullptr;
XMLElement* reg = root->FirstChildElement("registration");
if (reg) {
registration["progid"] = reg->Attribute("progid") ? reg->Attribute("progid") : "";
registration["classid"] = reg->Attribute("classid") ? reg->Attribute("classid") : "";
registration["description"] = reg->Attribute("description") ? reg->Attribute("description") : "";
registration["version"] = reg->Attribute("version") ? reg->Attribute("version") : "";
registration["remotable"] = reg->Attribute("remotable") ? reg->Attribute("remotable") : "";
}
XMLElement* public_elem = root->FirstChildElement("public");
if (public_elem) {
for (XMLElement* prop = public_elem->FirstChildElement("property"); prop; prop = prop->NextSiblingElement("property")) {
std::map<std::string, std::string> prop_map;
prop_map["name"] = prop->Attribute("name") ? prop->Attribute("name") : "";
prop_map["internalname"] = prop->Attribute("internalname") ? prop->Attribute("internalname") : "";
prop_map["get"] = prop->Attribute("get") ? prop->Attribute("get") : (prop->FirstChildElement("get") ? prop->FirstChildElement("get")->Attribute("internalname") : "");
prop_map["put"] = prop->Attribute("put") ? prop->Attribute("put") : (prop->FirstChildElement("put") ? prop->FirstChildElement("put")->Attribute("internalname") : "");
properties_list.push_back(prop_map);
}
for (XMLElement* method = public_elem->FirstChildElement("method"); method; method = method->NextSiblingElement("method")) {
std::map<std::string, std::string> method_map;
method_map["name"] = method->Attribute("name") ? method->Attribute("name") : "";
method_map["internalname"] = method->Attribute("internalname") ? method->Attribute("internalname") : "";
method_map["dispid"] = method->Attribute("dispid") ? method->Attribute("dispid") : "";
// Parameters would require nested vectors; simplified here
methods.push_back(method_map);
}
for (XMLElement* event = public_elem->FirstChildElement("event"); event; event = event->NextSiblingElement("event")) {
std::map<std::string, std::string> event_map;
event_map["name"] = event->Attribute("name") ? event->Attribute("name") : "";
event_map["dispid"] = event->Attribute("dispid") ? event->Attribute("dispid") : "";
events.push_back(event_map);
}
}
for (XMLElement* impl = root->FirstChildElement("implements"); impl; impl = impl->NextSiblingElement("implements")) {
std::map<std::string, std::string> impl_map;
impl_map["type"] = impl->Attribute("type") ? impl->Attribute("type") : "";
impl_map["id"] = impl->Attribute("id") ? impl->Attribute("id") : "";
impl_map["default"] = impl->Attribute("default") ? impl->Attribute("default") : "";
implements_handlers.push_back(impl_map);
}
for (XMLElement* obj = root->FirstChildElement("object"); obj; obj = obj->NextSiblingElement("object")) {
std::map<std::string, std::string> obj_map;
obj_map["id"] = obj->Attribute("id") ? obj->Attribute("id") : "";
obj_map["classid"] = obj->Attribute("classid") ? obj->Attribute("classid") : "";
obj_map["progid"] = obj->Attribute("progid") ? obj->Attribute("progid") : "";
objects.push_back(obj_map);
}
for (XMLElement* res = root->FirstChildElement("resource"); res; res = res->NextSiblingElement("resource")) {
std::map<std::string, std::string> res_map;
res_map["id"] = res->Attribute("id") ? res->Attribute("id") : "";
res_map["content"] = res->GetText() ? res->GetText() : "";
resources.push_back(res_map);
}
for (XMLElement* ref = root->FirstChildElement("reference"); ref; ref = ref->NextSiblingElement("reference")) {
std::map<std::string, std::string> ref_map;
ref_map["object"] = ref->Attribute("object") ? ref->Attribute("object") : "";
ref_map["guid"] = ref->Attribute("guid") ? ref->Attribute("guid") : "";
ref_map["version"] = ref->Attribute("version") ? ref->Attribute("version") : "";
references.push_back(ref_map);
}
for (XMLElement* com = root->FirstChildElement("comment"); com; com = com->NextSiblingElement("comment")) {
comments.push_back(com->GetText() ? com->GetText() : "");
}
for (XMLElement* scr = root->FirstChildElement("script"); scr; scr = scr->NextSiblingElement("script")) {
std::map<std::string, std::string> scr_map;
scr_map["language"] = scr->Attribute("language") ? scr->Attribute("language") : "";
scr_map["code"] = scr->GetText() ? scr->GetText() : "";
scripts.push_back(scr_map);
}
}
void printProperties() {
std::cout << "Component ID: " << component_id << std::endl;
std::cout << "Package Present: " << (package_present ? "true" : "false") << std::endl;
std::cout << "Registration:" << std::endl;
for (const auto& kv : registration) {
std::cout << " " << kv.first << ": " << kv.second << std::endl;
}
std::cout << "Public Properties:" << std::endl;
for (const auto& prop : properties_list) {
for (const auto& kv : prop) {
std::cout << " " << kv.first << ": " << kv.second << std::endl;
}
}
// Similarly print other sections (methods, events, etc.); abbreviated for brevity
}
void write(const std::string& new_filepath = "") {
doc.SaveFile((new_filepath.empty() ? filepath : new_filepath).c_str());
}
};
// Example usage:
// int main() {
// try {
// WSCFileHandler handler("example.wsc");
// handler.read();
// handler.printProperties();
// handler.write("modified.wsc");
// } catch (const std::exception& e) {
// std::cerr << e.what() << std::endl;
// }
// return 0;
// }